# 5. MicroPython教程
## 5.1 下载代码
请先下载本教程需要用到的所有：[MicroPython资料](./Python.7z)，保存至您方便使用的路径下。
**本MicroPython项目的所有实验都是以将代码文件夹移动到（D:）盘中为例的，移动后路径为** 。
## 5.2 下载安装Thonny
Thonny是一个免费、开源的软件平台，体积小，界面简单，操作简单，功能丰富，是一个适合初学者的Python IDE。在本教程中，我们使用 Thonny 这个IDE在整个实验课程过程中开发ESP32。Thonny支持多种操作系统，包括Windows, Mac OS, Linux。
（1）软件下载和开源代码库分享
- Thonny软件官网：[https://thonny.org](https://thonny.org)
请根据您的操作系统选择相应的版本下载。
也可以使用我们提供的安装包：
- Windows系统：
链接: [https://pan.baidu.com/s/1LNCP-fBc-P_SrdiMuaeijg?pwd=te7y](https://pan.baidu.com/s/1LNCP-fBc-P_SrdiMuaeijg?pwd=te7y) 提取码: te7y
- Mac系统：
链接: [https://pan.baidu.com/s/1Qd7ShCmdWUlR7KQJ7kyzCA?pwd=ee41](https://pan.baidu.com/s/1Qd7ShCmdWUlR7KQJ7kyzCA?pwd=ee41) 提取码: ee41
**注意：本教程使用的是 4.1.7 版本，请保持一致，以免出现代码不兼容情况。**
（2）下载完成后，鼠标左键双击“thonny-4.0.2.exe”。出现“Select Setup Install Mode”对话框，选择“**Install for all users**”。你也可以选择“Install for me only”进行操作。
（3）如果你不熟系电脑软件的安装，可以一直单击“**Next**”直至安装完成。
（4）Thonny软件的安装路径。默认此安装路径继续下一步，单击“**Next**”。如果您想选择一个不同的文件夹，请单击“**Browse...**”进行修改。
（5）程序将在下面的开始菜单文件夹中创建程序的快捷方式。默认此文件夹继续下一步，单击“**Next**”。如果您想选择一个不同的文件夹，请单击“**Browse...**”。
（6）选中“**Creak desktop icon**”，在桌面生成快捷方式。
（7）单击“**Install**”安装软件。等待安装成功。
（8）安装完成，单击“**Finish**”结束安装。
## 5.3 Thonny软件基本配置
（1）双击桌面的Thonny软件图标，出现语言选择和初始设置界面。
Language 选择“**简体中文**”。然后单击“**Let's go!**”结束设置。
（2）单击“**视图**”，勾选“**Shell**”和“**文件**”
## 5.4 Thonny软件的介绍
（1）工具栏介绍
| 按钮 | 功能 |
| :---------------------------------------------: | :---------------: |
|  | 新建 |
|  | 打开... |
|  | 保存 |
|  | 运行当前脚本 |
|  | 调试当前脚本 |
|  | 步过 |
|  | 步进 |
|  | 步出 |
|  | 恢复执行 |
|  | 停止/重启后端进程 |
（2）界面介绍
## 5.5 烧录固件
要在ESP32主板上运行Python程序，我们需要先将固件烧入到ESP32主板。
**5.5.1 下载Micropython固件**
- microPython官方网站：[http://micropython.org/](http://micropython.org/)
- microPython的ESP32固件：[https://micropython.org/download/esp32/](https://micropython.org/download/esp32/)
打开microPython的ESP32固件网址，下载固件。
本教程中使用的固件是：**esp32-20230426-v1.20.0.bin** 。我们的资料中也提供了此版本的固件，路径如下图。
**5.5.2 烧录Micropython固件**
（1）将ESP32主板通过USB线连接到计算机。
（2）确保驱动程序已成功安装，并能正确识别COM端口。打开设备管理器并展开“**端口**”。（端口号不是固定的COM6，会有不同，是正常情况。）
（3）打开Thonny，点击“**运行**” ，选择 “**配置解释器**”。
在解释器页面，解释器选择“**Micropython (ESP32)**”，端口或WebREPL选择“**USB-SERIAL CH340（COM6）**”（COM号以你电脑的端口为准）。然后单击“安装或更新MicroPython”。
弹出“ESP32 firmware installer”页面，“**Port**”下拉选择“**USB-SERIAL CH340（COM6）**”。
“**Firmware**”单击“**Browse...**”，选择下载好的microPython固件 “**esp32-20230426-v1.20.0.bin**”。
检查“**Flash mode**”是否选择了“**From image file(Keep)**”，“**Erase flash before installing**”是否勾选。
最后，单击“**安装**”，等待安装完成提示。
（4）安装完成，单击“**关闭**”。
在“Thonny 选项”页面单击“**好的**”。
（5）点击“**停止/重启后端进程**”按钮。
现在，一切准备工作都已就绪。
## 5.6 测试
**5.6.1 测试Shell命令**
在“**Shell**”窗口中输入“**print('hello world')**”，然后按下**Enter**键。
**5.6.2 在线运行**
ESP32需要连接到计算机时，是在线运行的。用户可以使用Thonny编写和调试程序。
（1）打开Tonny并单击，然后单击“**此电脑**”。
（2）在弹出的页面选择路径“**..\Python\Python_代码\01 Hello World**”下的“**lesson_01_HelloWorld.py**“Python 文件，然后单击”**打开**“。
（3）单击或按下“**F5**”键，Shell窗口将打印出”**Hello World**“。
**注意：** 如果在线运行时，按下ESP32的复位键，用户的代码将不会再次执行。如果你希望在重置代码后自动运行该代码，请参考下面章节 **5.3 离线运行** 的内容。
**5.6.3 离线运行**
ESP32复位后，首先运行根目录下的boot.py文件，然后运行你的代码文件，最后进入“Shell”。因此，为了让ESP32在重置后执行用户程序，我们需要在boot.py中添加一个引导程序来执行用户代码。
（1）将程序文件夹“**Python_代码**”（路径为：“**..\程序代码\Python_代码**”）移动到此电脑的(D)，命名为 代码，移动后路径为“**D:\代码**”。打开“Thonny”。
（2）打开Thonny，在文件管理框单击“**此电脑**”，双击“**（D:）**”，然后双击展开“**代码**”文件夹。
（3）展开“**00 Boot**”，然后鼠标左键双击“**boot\.py**”，使 “**MicroPython 设备**”中的程序能够离线运行。
（4）如果想让编写的程序离线运行，需要上传我们提供的“**boot\.py**”和你编写的程序代码到“**MicroPython 设备**”，然后按下ESP32的复位按键。
展开文件夹 00 Boot。右键单击“**boot\.py**”，选择“**上传到/**”。
单击“**确定**”。
（5）同样，将“**lesson_01_HelloWorld.py**”上传到 “**MicroPython 设备**”。
可以在 “**MicroPython 设备**”看到代码已成功上传。
（6）按下ESP32的**Reset按键**，在Shell窗口中能看到代码被执行。
## 5.7 Thonny常见的操作
**5.7.1 上传代码到ESP32**
为了方便起见，我们以**boot\.py**为例。如果我们在每个代码目录中都添加了boot\.py。ESP32每次重启时，它将首先执行根目录中的“**boot\.py**”。
在**02 LED**文件夹中选择“**boot\.py**”，右键单击鼠标，选择“**Upload to /**”将代码上传到ESP32的根目录，然后选择“**确定**”。
**5.7.2 下载代码到电脑**
在“**MicroPython 设备**”内选中“**boot\.py**”，右键选择“**下载到 D:\代码**”把代码下载到你的电脑里。
**5.7.3 删除ESP32根目录下的文件**
在“**MicroPython 设备**”内选中“**boot\.py**”，右键单击它且选择“**删除”**，将“**boot\.py**”从ESP32的根目录中删除。
在02 LED文件夹内选中“**boot\.py**”，右键单击它并选择“**移动到回收站**”将其从02 LED文件夹中删除。
**5.7.4 创建并保存代码**
单击“**文件**”，然后选择“**新建**”。
在新打开的文件中输写代码。（以lesson 02. LED.py的代码为例。）
单击菜单栏上的,可以将代码保存到你的电脑或ESP32上。这里选择保存到“MicroPython 设备”。
文件名命名为“**main\.py**”，然后单击“**好的**”。
代码已经上传到ESP32。
## 5.8 项目课程
---
### 第一课 Hello World
1.1 项目介绍
对于ESP32的初学者，先从一些简单的开始学习吧！在这个项目中，你只需要一个ESP32主板和USB线就可以完成“Hello World!”项目。它不仅是ESP32主板和计算机的通信测试，也是ESP32的初级项目。这也是一个入门实验，让你进入Python的编程世界。
---
1.2 实验组件
|  |  |
| :----------------------: | :-------------------: |
| ESP32 Plus主板 x1 | USB线 x1 |
---
1.3 实验接线图
---
1.4 在线运行代码
在线运行ESP32，需要把ESP32连接到电脑上，才可以使用Thonny软件编译或调试程序。
优点：
1. 可以编译或调试程序。
2. 通过“Shell”窗口，可以查看程序运行过程中产生的错误信息和输出结果，并可以在线查询相关功能信息，帮助改进程序。
缺点：
1. 要在线运行ESP32，必须将ESP32连接到一台电脑上并和Thonny软件一起运行。
2. 如果ESP32与电脑断开连接，当它们重新连接时，程序将无法再次运行。
本项目中使用的代码保存在文件夹“**..\程序代码\Python_代码**”中，你可以将代码移至任何你方便使用的地方。**本MicroPython课程的所有实验都是以将代码文件夹移动到（D:）盘中为例的**，命名为 代码，移动后路径为“**D:\代码**”。
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_01_HelloWorld.py**"。
```python
print("Hello World!")
print("Welcome to Keyestudio")
```
---
1.5 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，能看到“Shell”窗口打印出“**Hello World!**”、“**Welcome to Keyestudio**”。
当在线运行时，单击或按Ctrl+C退出程序。
---
### 第二课 LED
1.1 项目介绍
LED，即发光二极管的简称。由含镓（Ga）、砷（As）、磷（P）、氮（N）等的[化合物](https://baike.baidu.com/item/化合物/1142931)制成。当电子与[空穴](https://baike.baidu.com/item/空穴/3517781)复合时能辐射出可见光，因而可以用来制成发光二极管。在电路及仪器中作为指示灯，或者组成文字或数字显示。砷化镓二极管发红光，磷化镓二极管发绿光，碳化硅二极管发黄光，氮化镓二极管发蓝光。因化学性质又分有机发光二极管OLED和无机发光二极管LED。
为了实验的方便，我们将紫色LED发光二极管做成了一个紫色LED模块。它的控制方法非常简单，只要让LED两端有一定的电压就可以点亮LED。在这个项目中，我们用一个最基本的测试代码来控制LED，亮一秒钟，灭一秒钟，来实现闪烁的效果。你可以改变代码中LED灯亮灭的时间，实现不同的闪烁效果。我们通过编程控制信号端S的高低电平，从而控制LED的亮灭。LED模块信号端S为高电平时LED亮起，S为低电平时LED熄灭。
---
1.2 模块参数
工作电压：DC 3.3-5V
控制信号：数字信号
尺寸：32 x 23.5 x 12 mm
定位孔大小：直径为 4.8 mm
接口：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
这是一个常用的LED模块，它采用F5-白发紫LED（外观白色，显示紫光）元件。同时，模块上自带一个间距为2.54mm的防反插红色端子。控制时，模块上GND VCC供电后，信号端S为高电平时，模块上LED亮起。
模块兼容各种单片机控制板，如arduino系列单片机。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 紫色LED模块 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
本项目中使用的代码保存在文件夹“**..\程序代码\Python_代码**”中，你可以将代码移至任何你方便使用的地方。本课程的所有实验都是以将代码文件夹移动到（D:)盘中为例的，命名为 代码，移动后路径为“**D:\代码**”。
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_02_Blink.py**"。
```python
from machine import Pin
import time
led = Pin(5, Pin.OUT)# 搭建一个LED对象，将外接LED灯连接到5号引脚，设置5号引脚为输出模式
while True:
led.value(1)#打开灯
time.sleep(1)# 延迟1s
led.value(0)# 关闭灯
time.sleep(1)# 延迟1s
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，能看到模块上的紫色LED一亮一灭，循环闪烁。
---
1.8 代码说明
| 代码 | 说明 |
| ----------------------- | ------------------------------------------------------------ |
| from machine import Pin | machine模块里对ESP32主板的一些配置等已经设置好了，我们需导入它，然后调用。 |
| time.sleep(1) | time模块主要是用于时间延迟设置。括号里是1，延时1秒。 |
| led = Pin(5, Pin.OUT) | 构建一个引脚类实例，我们将其命名为led，5表示我们连接的引脚为GP5，Pin.OUT表示引脚5为输出模式，即可以使用value()方法输出高电平(3.3V) ：led.value(1)，或者低电平(0V) ：led.value(0)。 |
| while True: | 循环函数，在此函数下面的语句循环执行，除非True变False。 |
---
### 第三课 交通灯模块
1.1 项目介绍
交通灯，也就是马路上十字路口的红绿灯，在我们的日常生活中很常见。交通灯是由红、黄、绿三种颜色组成的，根据一定的时间规律循环交替亮起或熄灭。每个人都应该遵守交通规则，这可以避免许多交通事故。
想学习交通灯的原理吗？我们可以用红、黄、绿3个LED外接电路来模拟马路上的交通灯。因此我们特别设计了这款交通灯模块，模块上的红、黄、绿3个LED灯模拟交通灯。
---
1.2 模块参数
工作电压 : DC 5V
电流 ：100 mA
最大功率 ：0.5 W
工作温度 ：-10°C ~ +50°C
输入信号 : 数字信号
尺寸 ：47.6 x 23.8 x 11.8 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 5pin防反接口
---
1.3 模块原理图
前面实验二我们就学习了如何控制一个LED，由原理图可以得知，控制这个模块就好比分别控制3个独立的LED灯(我们这个灯可直接由单片机IO口驱动)，给对应颜色灯高电平就亮起对应的颜色。比如，我们给信号“R”输出高电平，也就是3.3V，则红色LED点亮。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 交通灯模块 x1 | XH2.54-5P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_03_Traffic_Light.py**"。
```python
import machine
import time
led_red = machine.Pin(5, machine.Pin.OUT)
led_yellow = machine.Pin(13, machine.Pin.OUT)
led_green = machine.Pin(12, machine.Pin.OUT)
while True:
led_green.value(1) # 绿灯亮
time.sleep(5) # 延迟5 s
led_green.value(0) # 绿灯关闭
for i in range(3): #黄灯闪烁3次
led_yellow.value(1)
time.sleep(0.5)
led_yellow.value(0)
time.sleep(0.5)
led_red.value(1) # 红灯亮
time.sleep(5) # 延迟5 s
led_red.value(0) #红灯关闭
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，能看到模块上绿色LED亮5秒然后熄灭，黄色LED闪烁3次然后熄灭，红色LED亮5秒然后熄灭。模块按此顺序循环亮灭。
单击或按Ctrl+C退出程序。
---
1.8 代码说明
| 代码 | 说明 |
| ----------------- | ------------------------------------------------------------ |
| range () | range () 函数的使用 ：range(start, stop,[ step])，分别是起始、终止和步长。range（3）即：从0到3，不包含3，即0,1,2。 |
| for i in range(3) | for i in range()函数的基本用法是启动一个循环，从一个给定的数开始，依次递增的遍历到给定的数字，并在遇到其他条件下停止。结合range(3)可以知道这里是让黄灯闪烁3次（0,1,2共3次）的意思。亮0.5秒，灭0.5秒组成一次闪烁。 |
---
### 第四课 呼吸灯
1.1 项目介绍
在第二课我们学习了如何让LED闪烁。但是LED的玩法远不仅如此。在日常生活中你有没有遇到过灯光慢慢变亮或者慢慢变暗呢？这叫呼吸灯。所谓呼吸灯，就是控制LED逐渐变亮，然后逐渐变暗，循环交替。上一课我们学会了直接用高电平点亮LED，低电平熄灭LED。如果要让LED不那么亮但又不完全熄灭，介于中间状态，只需控制流过LED的电流就可以实现。电流减小LED变暗，电流增大LED变亮。所以只需要调节LED两端的电压减小或增大（电流也会随之减小或增大）就能控制LED的亮暗程度了。
数字端口电压输出只有LOW与HIGH两个开关，对应的就是0V与3.3V（或5V）的电压输出。可以把LOW定义为0，HIGH定义为1，1秒内让单片机输出500个0或者1的信号。如果这500个信号全部为1，那就是完整的3.3V；如果全部为0，那就是0V。如果010101010101这样输出，刚好一半，端口输出的平均电压就为1.65V了。这和放映电影是一个道理。我们所看的电影并不是完全连续的，它其实是每秒输出25张图片，人的肉眼分辨不出来，看上去就是连续的了，PWM也是同样的道理。如果想要不同的电压，就控制0与1的输出比例就可以了。当然这和真实的连续输出还是有差别的，单位时间内输出的0,1信号越多，控制的就越精确。
那么什么是PWM呢？PWM简称脉宽调制，是利用微处理器的数字输出来对模拟电路进行控制的一种非常有效的技术。
PWM的频率是指在1秒钟内，信号从高电平到低电平再回到高电平的次数，也就是说一秒钟PWM有多少个周期，单位Hz。
PWM的周期，T=1/f，T是周期，f是频率。如果频率为50Hz ，也就是说一个周期是20ms，那么一秒钟就有 50次PWM周期。
占空比，是一个脉冲周期内，高电平的时间与整个周期时间的比例，单位是% (0%-100%) 一个周期的长度。如下图所示。
这一课学习使用PWM来控制0与1的输出比例实现控制电压。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
工作温度 ：-10°C ~ +50°C
控制信号 : 数字信号
尺寸 ：32 x 23.8 x 12 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
前面实验二我们就学习了如何控制一个LED，由原理图可以得知，控制时，模块上GND VCC供电后，信号端S为高电平时，模块上LED亮起。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 紫色LED模块 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_04_Breath.py**"。
```python
import time
from machine import Pin,PWM
#ESP32 PWM引脚输出的方式与传统控制器不同
#在初始化阶段通过配置PWM的参数，可以改变频率和占空比
#定义GPIO 5的输出频率为10000Hz，占空比为0，分配给PWM
pwm =PWM(Pin(5,Pin.OUT),10000)
try:
while True:
#占空比范围为0-1023，因此我们使用第一个for环来控制PWM以改变占空比
#周期值，使PWM输出0% -100%;使用第二个for环路使PWM输出100%-0%
for i in range(0,1023):
pwm.duty(i)
time.sleep_ms(1)
for i in range(0,1023):
pwm.duty(1023-i)
time.sleep_ms(1)
except:
#每次使用PWM时，硬件定时器将打开以配合它。因此，每次使用PWM后
#需要调用deinit()来关闭计时器。否则会导致下次PWM工作失败
pwm.deinit()
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，能看到模块上的紫色LED从暗逐渐变亮，再从亮逐渐变暗，就像呼吸一样。
单击或按Ctrl+C退出程序。
---
1.8 代码说明
| 代码 | 说明 |
| ------------ | ------------------------------------------------------------ |
| pwm.deinit() | 每次使用PWM时，硬件定时器将打开以配合它。因此，每次使用PWM后，需要调用deinit()来关闭计时器。否则会导致下次PWM工作失败。 |
---
### 第五课 RGB模块调节LED颜色
1.1 项目介绍
在这个套件中，有一个Keyes 共阴RGB模块，它采用F10-全彩RGB雾状共阴LED元件。控制时，我们需要将模块的R、G、B脚连接至单片机的PWM口。由于我们这个RGB模块是共阴的，公共管脚就接GND（共阳RGB公共管脚接VCC)。
RGB三色也就是三基色，红色、绿色、蓝色。人眼对RGB三色最为敏感，大多数的颜色可以通过RGB三色按照不同的比例合成产生。同样绝大多数单色光也可以分解成RGB三种色光。这是色度学的最基本原理，即三基色原理。RGB三基色按照不同的比例相加合成混色称为相加混色，除了相加混色法之外还有相减混色法。可根据需要相加相减调配颜色。
接下来，我们基于刚刚学习的三基色原理，通过PWM端口控制R、G、B各色的占空比，使R、G、B三色按照不同的比例合成产生多重颜色显示在LED上。
---
1.2 模块参数
工作电压 ：DC 3.3 ~ 5V
工作温度 ：-10°C ~ +50°C
输入信号 ：PWM信号
尺寸 ：32 x 23.8 x 16.9 mm
定位孔大小 ：直径为 4.8 mm
接口 ：间距为2.54 mm 4pin防反接口
---
1.3 模块原理图
通过调节R、G、B、三个灯的PWM值，控制LED元件显示红光、绿光和蓝光的比例，从而控制RGB模块上LED显示不同颜色灯光。当设置的PWM值越大，对应显示的颜色比例越重。理论上来说，通过调节这3中颜色光的混合比例，可以模拟出所有颜色的灯光。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 共阴RGB模块 x1 | XH2.54-4P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_05_RGB.py**"。
```python
#导入Pin, PWM和Random功能模块
from machine import Pin, PWM
from random import randint
import time
#配置GPIO32、GPIO4和GPIO2的输出模式为PWM输出，PWM频率为10000Hz
pins = [32, 4, 2]
pwm0 = PWM(Pin(pins[0]),10000)
pwm1 = PWM(Pin(pins[1]),10000)
pwm2 = PWM(Pin(pins[2]),10000)
#定义一个函数来设置RGBLED的颜色
def setColor(r, g, b):
pwm0.duty(1023-r)
pwm1.duty(1023-g)
pwm2.duty(1023-b)
try:
while True:
red = randint(0, 1023)
green = randint(0, 1023)
blue = randint(0, 1023)
setColor(red, green, blue)
time.sleep_ms(200)
except:
pwm0.deinit()
pwm1.deinit()
pwm2.deinit()
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，能看到模块上RGB LED开始随机显示颜色。
单击或按Ctrl+C退出程序。
---
1.8 代码说明
| 代码 | 说明 |
| ------------------------------ | -------------------------------------------------- |
| pins = [32, 4, 2] | 定义一个数组，这个数组是红灯、绿灯、蓝灯的引脚号。 |
| pwm0 = PWM(Pin(pins[0]),10000) | 定义GP32脚为PWM输出并命名为pwm0，频率为10000Hz。 |
| pwm0.duty(1023-r) | 设置占空比. |
| randint(a，b) | randint(a,b)函数：生成一个[a,b]之间的随机整数。 |
---
### 第六课 按键传感器检测实验
1.1 项目介绍
在这个套件中，有一个Keyes单路按键模块，它主要由1个轻触开关组成，自带1个黄色按键帽。第二课我们学习了怎么让单片机的引脚输出一个高电平或者低电平，这节课程我们就来学习怎么读取引脚的电平。
按键模块的按键按下，单片机读取到低电平，松开按键读取到高电平。通过读取传感器上S端的高低电平，判断按键是否按下，并且在"Shell"窗口上显示测试结果。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
工作温度 ：-10°C ~ +50°C
控制信号 : 数字信号
尺寸 ：32 x 23.8 x 15.6 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
按键有四个引脚，其中1与3相连，2与4相连。按键未被按下时，13与24是断开的。信号端S读取的电平是被4.7K的上拉电阻R1所拉高的高电平。而当按键被按下时，13和24连通，原本上拉的13脚被24脚接的GND下拉至低电平，此时信号端S读取到低电平。即按下按键，传感器信号端S为低电平；松开按键时，信号端S为高电平。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 单路按键模块 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_06_button.py**"。
```python
from machine import Pin
import time
button = Pin(5, Pin.IN, Pin.PULL_UP)
while True:
if button.value() == 0:
print("You pressed the button!") #按下打印相应信息
else:
print("You loosen the button!")
time.sleep(0.1) #延时0.1秒
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，当按下传感器模块上的按键时，按键值value为0，"Shell"窗口打印出“**You pressed the button!**”；松开按键时，按键值value为1，"Shell"窗口打印出“**You loosen the button!**”字符。
单击或按Ctrl+C退出程序。
---
1.8 代码说明
| 代码 | 说明 |
| ------------------------------------ | ------------------------------------------------------------ |
| button = Pin(5, Pin.IN, Pin.PULL_UP) | 定义按键管脚为GPIO5，设置为输入上拉模式。如果使用button = Pin(5, Pin.IN)设置为输入模式而不使用输入上拉，此时引脚处于高阻抗状态，会导致不可预测的电平结果。为了确保开关断开时的读数正确，推荐使用上拉或下拉电阻。我们的模块已经使用上拉电阻R1，可以不设置输入上拉，该电阻的目的是在开关断开时将引脚拉至已知状态。通常选择一个4.7K/10 K欧姆的电阻，因为它的阻值足够低，可以可靠地防止输入悬空，同时，该阻值也要足够高，以使开关闭合时不会消耗太多电流。如果使用下拉电阻，则当开关断开时，输入引脚将为低电平；当开关闭合时，输入引脚将为高电平。如果使用上拉电阻，则当开关断开时，输入引脚将为高电平；当开关闭合时，输入引脚将为低电平。 |
| button.value() | 读取按键的数字电平，函数返回高(HIGH)或者低(LOW)。 |
| if.. else：.. | 当if后面的逻辑判断为True时，执行if下缩进的代码；否则执行else下缩进的代码。python代码是严格使用缩进的。 |
---
### 第七课 避障传感器检测障碍物
1.1 项目介绍
在这个套件中，有一个Keyes 避障传感器，它主要由一对红外线发射与接收管元件组成。实验中，我们通过读取传感器上S端高低电平，判断是否存在障碍物；并且，在串口监视器上显示测试结果。
---
1.2 模块参数
工作电压 : DC 5V
电流 : 50 mA
最大功率 : 0.3 W
工作温度 ：-10°C ~ +50°C
输出信号 : 数字信号
感应距离 : 2 ~ 40 cm
尺寸 ：32 x 23.8 x 11 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
NE555时基电路提供给发射管TX发射出一定频率的红外信号，红外信号会随着传送距离的加大逐渐衰减，如果遇到障碍物，就会形成红外反射。当检测方向RX遇到反射回来的信号比较弱时，接收检测引脚输出高电平，说明障碍物比较远；当反射回来的信号比较强，接收检测引脚输出低电平，说明障碍物比较近，此时指示灯亮起。传感器上有两个电位器，一个用于调节发送功率，一个用于调节接收频率，通过调节两个电位器，我们可以调节它的有效距离。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 避障传感器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_07_Avoiding.py**"。
```python
from machine import Pin
import time
sensor = Pin(5, Pin.IN)
while True:
if sensor.value() == 0:
print("There are obstacles")
else:
print("All going well")
time.sleep(0.1)
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，接着开始调节传感器模块上的两个电位器感应距离。避障传感器上有两个电位器，分别是接收频率调节电位器和发射功率调节电位器，如下图所示。
**注意：**调节时保持传感器前方没有障碍物阻挡，否则调节后的检测距离较短。
先调节发射功率调节电位器，先将电位器顺时针到尽头，然后逆时针慢慢往回调，当调节到SLED灯亮起时，微调使传感器上SLED灯介于亮与不亮之间的**不亮**状态。
接着设置接收频率调节电位器，同样将电位器顺时针到尽头，然后逆时针慢慢往回调，当SLED灯亮起时，微调使传感器上SLED灯介于亮与不亮之间的**不亮**状态，此时能检测障碍物的距离最长。
调节完成后查看“Shell”窗口。当传感器检测到障碍物时，value值为**0**，SLED灯亮，“Shell”窗口打印出 “**There are obstacles**” ；没有检测到障碍物时，value值为**1**，SLED灯灭，“Shell”窗口打印出 “**All going well**” 。
单击或按Ctrl+C退出程序。
---
1.8 代码说明
此课程代码与第六课代码类似，这里就不多做介绍了。
---
### 第八课 倾斜模块的原理
1.1 项目介绍
在这个套件中，有一个Keyes 倾斜传感器，主要由一个倾斜开关组成，其内部带有一颗滚珠，用来监测倾斜情况。倾斜开关可以依据模块是否倾斜而输出不同的电平信号。当开关高于水平位置倾斜时开关导通，低于水平位置时开关断开。倾斜模块可用于倾斜检测、报警器制作或者其他检测。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
电流 : 50 mA
最大功率 : 0.3 W
工作温度 ：-10°C ~ +50°C
输出信号 : 数字信号
尺寸 ：32 x 23.8 x 8 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
Keyes 倾斜传感器的原理非常简单，主要是利用滚珠在开关内随不同倾斜角度的变化使滚珠开关P1的引脚1和2导通或者不导通，当滚珠开关P1的引脚1和2导通时，由于1脚接GND，所以信号端S被拉低为低电平，此时红色LED和R2组成的电路形成回路，电流经过红色LED，点亮红色LED；当滚珠开关P1的引脚1和2不导通时，滚珠开关P1的引脚2被4.7K的上拉电阻R1拉高使得信号端S为高电平，电流不经过红色LED，红色LED熄灭。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 倾斜传感器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_08_Tilt_switch.py**"。
```python
from machine import Pin
import time
TiltSensor = Pin(5, Pin.IN)
while True:
value = TiltSensor.value()
print(value, end = " ")
if value== 0:
print("The switch is turned on")
else:
print("The switch is turned off")
time.sleep(0.1)
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，将倾斜模块往某一边倾斜，若模块上的红色LED**不亮**，“Shell”窗口打印出“**1 The switch is turned off**”；若模块上的红色LED点**亮**，“Shell”窗口打印出“**0 The switch is turned on**”。
---
1.8 代码说明
此课程代码与第六课代码类似，这里就不多做介绍了。
---
### 第九课 干簧管检测附近磁场
1.1 项目介绍
在这个套件中，有一个Keyes 干簧管模块，它主要由一个MKA10110 绿色磁簧元件组成。簧管是干式舌簧管的简称，是一种有触点的无源电子开关元件，具有结构简单，体积小便于控制等优点。它的外壳是一根密封的玻璃管，管中装有两个铁质的弹性簧片电板，还灌有一种惰性气体。
实验中，我们通过读取模块上S端高低电平，判断模块附近是否存在磁场；并且在“Shell”窗口上显示测试结果。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
电流 : 50 mA
最大功率 : 0.3 W
工作温度 ：-10°C ~ +50°C
输出信号 : 数字信号
尺寸 ：32 x 23.8 x 7.4 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
一般状态下，玻璃管中的两个由特殊材料制成的簧片是分开的，此时信号端S被电阻R2上拉为高电平，LED熄灭。当有磁性物质靠近玻璃管时，在磁场磁力线的作用下，管内的两个簧片被磁化而互相吸引接触，簧片就会吸合在一起，使结点所接的电路连通，即信号端S连通GND，此时LED点亮。外磁力消失后，两个簧片由于本身的弹性而分开，线路也就断开了。该传感器就是利用元件这一特性，搭建电路将磁场信号转换为高低电平变换信号。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 干簧管模块 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_09_Reed_Switch**"。
```python
from machine import Pin
import time
ReedSensor = Pin(5, Pin.IN)
while True:
value = ReedSensor.value()
print(value, end = " ")
if value == 0:
print("A magnetic field")
else:
print("There is no magnetic field")
time.sleep(0.1)
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行。
拿一块带有磁性的物体靠近干簧管模块，当模块检测到磁场时，value值为0且模块上的红色LED点亮，“Shell”窗口打印出“**0 A magnetic field**”；没有检测到磁场时，value值为1，模块上红色LED熄灭，“Shell”窗口打印出“**1 There is no magnetic field**”。
---
1.8 代码说明
此课程代码与第六课代码类似，这里就不多做介绍了。
---
### 第十课 附近有人吗
1.1 项目介绍
在这个套件中，有一个Keyes 人体红外热释传感器，它主要由一个RE200B-P传感器元件组成。它是一款基于热释电效应的人体热释运动传感器，能检测到人体或动物身上发出的红外线，配合菲涅尔透镜能使传感器探测范围更远更广。
实验中，通过读取模块上S端高低电平，判断附近是否有人在运动；并且在串口监视器上显示测试结果。
---
1.2 模块参数
工作电压 : DC 5 ~ 15V
工作电流 : 50 mA
最大功率 : 0.3 W
静态电流 : <50 uA
工作温度 ：-10°C ~ +50°C
控制信号 : 数字信号
触发方式 : L 不可重复触发/H 重复触发
最大检测距离 : 7米
感应角度 : <100 度锥角
尺寸 ：32 x 23.8 x 7.4 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
这个模块的原理图可能较前面的模块稍复杂，我们一部分一部分来看。先看电压转换部分，作用是将5V输入电压转换为3.3V输入电压。因为我们模块上用到的热释电红外传感器的工作电压是3.3V，不能直接用5V电压供电使用。有了这个电压转换部分，3.3V输入电压和5V输入电压都适用于此热释电红外传感器。
当红外热释传感器没有检测到红外信号时，红外热释传感器的1脚输出低电平，此时模块上的LED两端有电压差，有电流流过，LED被点亮，MOS管Q1导通（Q1是NPN MOS管，型号为2N7002。由于红外热释传感器的1脚输出低电平，所以Q1的源极Vs=0V，而Q1的栅极Vg=3.3V，于是Q1的栅极G和Q1的源极S之间的电压 Vgs = 3.3V 大于Q1的阈值电压 2.5V，Q1导通。），信号端S检测到低电平。
当红外热释传感器检测到红外信号时，红外热释传感器的1脚输出高电平，此时模块上的LED熄灭，MOS管Q1不导通，则信号端S检测到被10K上拉电阻R5拉高的高电平。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | --------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 人体红外热释传感器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_10_PIR_motion.py**"。
```python
from machine import Pin
import time
PIR = Pin(5, Pin.IN)
while True:
value = PIR.value()
print(value, end = " ")
if value == 1:
print("Some body is in this area!")
else:
print("No one!")
time.sleep(0.1)
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行.
当传感器检测到附近有人在运动时，value值为1，模块上LED熄灭，串口监视器显示“**1 Somebody is in this area!**”；没有检测到附近有人在运动时，value值为0，模块上LED点亮，串口监视器显示“**0 No one!**”。
---
1.8 代码说明
此课程代码与第六课代码类似，这里就不多做介绍了。
---
### 第十一课 有源蜂鸣器模块播放声音
1.1 项目介绍
在这个套件中，有一个有源蜂鸣器模块，还有一个功放模块（原理相当于无源蜂鸣器）。在这个实验中，我们来学习尝试控制有源蜂鸣器发出声音。有源蜂鸣器元件内部自带震荡电路，使用时，我们只需要给蜂鸣器元件足够的电压，蜂鸣器就会自动响起。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
工作温度 ：-10°C ~ +50°C
输入信号 : 数字信号
尺寸 ：32 x 23.8 x 12.3 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
从原理图我们可以得知，蜂鸣器的1脚通过串联一个电阻R2连接到电压正极；蜂鸣器的2脚连接到NPN三极管Q1的C极，集电极；Q1的B极，也就是基极通过串联一个电阻R1连接到S信号端；发射集接到GND。
当三极管Q1导通时，蜂鸣器的2脚连通GND，有源蜂鸣器便会工作。那么如何让三极管Q1导通呢？**NPN三极管的导通条件是基极（B）电压比发射极（E）电压高 0.3V 以上，**只需要基极（B）被上拉至高电平即可。虽然三极管Q1的基极（B）有一个下拉电阻R3导致其不导通，但是R3电阻的阻值大，使其为弱下拉电阻。三极管Q1的基极（B）还连接了一个阻值小的强上拉电阻R1，只要我们用单片机IO口给S信号端输入高电平，强上拉电阻R1会将三极管Q1的基极（B）强上拉为高电平，三极管Q1就会导通，有源蜂鸣器就会工作。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 有源蜂鸣器模块 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_11_Active_buzzer.py**"。
```python
from machine import Pin
import time
buzzer = Pin(5, Pin.OUT)
while True:
buzzer.value(1)
time.sleep(1)
buzzer.value(0)
time.sleep(1)
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，模块上有源蜂鸣器响起1秒，停1秒，循环交替。
---
### 第十二课 8002b功放 喇叭模块
1.1 项目介绍
在这个套件中，有一个Keyes 8002b功放 喇叭模块，这个模块主要由一个可调电位器、一个喇叭和一个音频放大芯片组成。上一课我们学习了有源蜂鸣器模块的使用方法，这一课我们来学习套件中的8002b功放 喇叭模块的使用方法。这个模块主要功能是：可以对输出的小音频信号进行放大，大概放大倍数为8.5倍，并且可以通过自带的小功率喇叭播放出来，也可以用来播放音乐，作为一些音乐播放设备的外接扩音设备。
---
1.2 模块参数
工作电压 : DC 5V
工作电流 : ≥100 mA
最大功率 : 2.5 W
喇叭功率 : 0.15 W
喇叭声音 : 80 db
放大芯片 : SC8002B
工作温度 ：-10°C ~ +50°C
尺寸 ：47.6 x 23.8 x 10 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
其实这个喇叭就类似于于一个无源蜂鸣器，上一课我们介绍过，有源蜂鸣器自带振荡源，只要我们给它足够的电压就能响起来，而无源蜂鸣器元件内部不带震荡电路，需要在元件正极（也就是1脚）输入不同频率的方波，负极（也就是2脚）接地，从而控制蜂鸣器响起不同频率的声音。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | --------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 8002b功放 喇叭模块 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_12_Passive_buzzer.py**"。
```python
from machine import Pin, PWM
from time import sleep
buzzer = PWM(Pin(4))
buzzer.duty(1000)
buzzer.freq(523)#DO
sleep(0.5)
buzzer.freq(586)#RE
sleep(0.5)
buzzer.freq(658)#MI
sleep(0.5)
buzzer.freq(697)#FA
sleep(0.5)
buzzer.freq(783)#SO
sleep(0.5)
buzzer.freq(879)#LA
sleep(0.5)
buzzer.freq(987)#SI
sleep(0.5)
buzzer.duty(0)
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，功放喇叭模块循环播放对应频率对应节拍的声音：DO，Re，Mi，Fa，So，La，Si各响半秒。如果觉得喇叭声音太大或太小，可以使用十字螺丝刀调节模块上的电位器以调整音量大小。
---
1.8 代码说明
| 代码 | 说明 |
| -------------------- | ------------------------------------------------------------ |
| buzzer = PWM(Pin(4)) | 创建一个PWM类实例，蜂鸣器引脚连接GPIO4。 |
| buzzer.duty(1000) | 设置占空比，占空比为1000/4950，这个值越大蜂鸣器越响，设置为0时蜂鸣器不响。 |
| buzzer.freq(523) | 频率设置方法。声音的音调取决于频率，设置好频率就可以设置音调。 |
---
### 第十三课 读取旋转电位器传感器的值
1.1 项目介绍
在这个套件中，有一个Keyes 旋转电位器传感器，它一个模拟传感器。前面我们学习过的传感器，都是数字传感器。例如我们前面学习的按键模块，当按键没有按下去时，我们读取到高电平（3.3V），当按键按下去时，我们读取到低电平（0V），而在0~3.3V中间的电压值，我们数字IO口无法读取到，当然按键模块也只能输出高低电平。而模拟传感器就可以通过我们ESP32主板上的16个ADC模拟口读取中间的电压值。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
工作电流 : 20 mA
工作功率 : 0.1 W
工作温度 ：-10°C ~ +50°C
输出信号 : 模拟信号
尺寸 ：32 x 23.8 x 28.4 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
旋转电位器原理是靠电刷在电阻体上滑动，在电路中获取与输入电压形成一定关系地输出电压。Keyes 旋转电位器传感器选用了一个10K可调电阻。通过旋转电位器，我们可以改变电阻大小，信号端S检测到电压变化（0 ~ 3.3V），而这个电压变化是一个连续变化的模拟量，也就是在0~3.3V内可以取任意值，我们必须先对这个模拟量进行ADC采集，来测量连续的这些模拟量。A/D 是模拟量到数字量的转换，依靠的是模数转换器(Analog to Digital Converter)，简称ADC。我们的ESP32主板已经集成了ADC采集，可以直接使用。
我们的ESP32主板ADC位数是12位。一个 n 位的 ADC 表示这个 ADC 共有 2 的 n 次方个刻度，12位的 ADC，输出的是从0～4095一共4096个数字量，也就是 2 的 12 次方个数据刻度，每个刻度就是3.3V/4095≈0.00081V，这也叫分辨率。
ADC：ADC是一种电子集成电路，用于将模拟信号(如电压)转换为由1和0表示的数字信号。我们在ESP32上的ADC的范围是12位（ADC的位数表示将模拟量转换成数字量后所用的二进制位数），其可存储数字量范围为：0 ~ 2^12即0 ~ 4096。假设它的参考电压是3.3V，也就是说把参考电压分成4095份，最小分辨率为3.3V/4095，模拟值的范围对应于ADC值。因此，ADC拥有的比特越多，模拟的分区就越密集，最终转换的精度也就越高。
纵坐标数字0 : 0V ~ 3.3/4095V 范围内的模拟量（横坐标）;
纵坐标数字1 : 3.3/ 4095V ~ 2*3.3 /4095V 范围内的模拟量（横坐标）;
......
模拟将被相应地划分。换算公式如下：
DAC：这一过程的可逆需要DAC，数字到模拟转换器。数字I/O端口可以输出高电平和低电平(0或1)，但不能输出中间电压值，这就是DAC有用的地方。ESP32有两个8位精度的DAC输出引脚GPIO25和GPIO26，可以将VCC(这里是3.3V)分成2*8=256个部分。例如，当数字量为1时，输出电压值为3.3/256 * 1V，当数字量为128时，输出电压值为3.3/256 *128=1.65V, DAC的精度越高，输出电压值的精度就越高。
换算公式如下：
ADC on ESP32：
ESP32有16个引脚，可以用来测量模拟信号。GPIO引脚序列号和模拟引脚定义如下表所示：
| **ADC number in ESP32** | **ESP32 GPIO number** |
| ----------------------- | --------------------- |
| ADC0 | GPIO 36 |
| ADC3 | GPIO 39 |
| ADC4 | GPIO 32 |
| ADC5 | GPIO33 |
| ADC6 | GPIO34 |
| ADC7 | GPIO 35 |
| ADC10 | GPIO 4 |
| ADC11 | GPIO0 |
| ADC12 | GPIO2 |
| ADC13 | GPIO15 |
| ADC14 | GPIO13 |
| ADC15 | GPIO 12 |
| ADC16 | GPIO 14 |
| ADC17 | GPIO27 |
| ADC18 | GPIO25 |
| ADC19 | GPIO26 |
DAC on ESP32：
ESP32有两个8位数字模拟转换器，分别连接到GPIO25和GPIO26引脚，它是不可变的。如下表所示：
| **Simulate pin number** | **GPIO number** |
| ----------------------- | --------------- |
| DAC1 | GPIO25 |
| DAC2 | GPIO26 |
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 旋转电位器传感器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_13_potentiometer.py**"。
```python
### 导入引脚、ADC和DAC模块
from machine import ADC,Pin,DAC
import time
### 开启并配置ADC，量程为0-3.3V
adc=ADC(Pin(34))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_12BIT)
### 每0.1秒读取一次ADC值，将ADC值转换为DAC值输出;
#并将这些数据打印到“Shell”
try:
while True:
adcVal=adc.read()
dacVal=adcVal//16
voltage = adcVal / 4095.0 * 3.3
print("ADC Val:",adcVal,"DACVal:",dacVal,"Voltage:",voltage,"V")
time.sleep(0.1)
except:
pass
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，转动电位器手柄时，“Shell”窗口打印出此时电位器的ADC值、DAC值和电压的值。
---
1.8 代码说明
| 代码 | 说明 |
| ------------------------------- | ------------------------------------------------------------ |
| from machine import ADC,Pin,DAC | 使用ACD、DAC模块之前，需要将它们添加到python文件的顶部。 |
| adc=ADC(Pin(34)) | 创建一个与给定pin关联的DAC对象。pin：可用的引脚是Pin(36)、Pin(39)、Pin(34）、Pin(35)、Pin(32)、Pin(33)。 |
| adc.read() | 读取ADC值并返回ADC值。 |
| adc.atten(ADC.ATTN_11DB) | 设定衰减比。 |
| DB | 衰减比 / 衰减率。 |
| ADC.ATTN_11DB | 3.3V全量程。 |
| adc.width(ADC.WIDTH_12BIT) | 设置数据宽度。 |
| ADC.WIDTH_12BIT | 12数据宽度。 |
---
### 第二十四课 声音传感器检测声量
1.1 项目介绍
在这个套件中，有一个Keyes 声音传感器。实验中，我们利用这个传感器测试当前环境中的声音对应的ADC值、DAC值和输出的电压值。声音越大，ADC值、DAC值和电压值越大；并在“Shell”窗口上显示测试结果。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
工作电流 : 100 mA
最大功率 : 0.5 W
工作温度 ：-10°C ~ +50°C
输出信号 : 模拟信号
尺寸 ：32 x 23.8 x 10.3 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
Keyes 声音传感器主要由一个高感度麦克风元件和LM386音频功率放大器芯片组成。高感度麦克风元件用于检测外界的声音。利用LM386音频功率放大器芯片设计对高感度麦克风检测到的声音进行放大的电路，最大倍数为200倍。使用时我们可以通过旋转传感器上电位器，调节声音的放大倍数。顺时针调节电位器到尽头，放大倍数最大。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 声音传感器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_14_MicroPhone.py**"。
```python
#导入引脚、ADC和DAC模块
from machine import ADC,Pin,DAC
import time
### 开启并配置ADC，量程为0-3.3V
adc=ADC(Pin(34))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_12BIT)
### 每0.1秒读取一次ADC值，将ADC值转换为DAC值输出
### 并将这些数据打印到“Shell”
try:
while True:
adcVal=adc.read()
dacVal=adcVal//16
voltage = adcVal / 4095.0 * 3.3
print("ADC Val:",adcVal,"DACVal:",dacVal,"Voltage:",voltage,"V")
time.sleep(0.1)
except:
pass
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。
代码开始执行，“Shell”窗口打印出声音传感器接收到的声音对应的ADC值、DAC值和电压值。对准MIC头大声说话，可以看到接收到的声音对应的ADC值、DAC值和电压值变大。
---
1.8 代码说明
此课程代码与第十三课代码类似，这里就不多做介绍了。
---
### 第十五课 光敏电阻传感器
1.1 项目介绍
在这个套件中，有一个Keyes 光敏电阻传感器，这是一个常用的光敏电阻传感器，它主要由一个光敏电阻元件组成。光敏电阻元件的阻值随着光照强度的变化而变化，此传感器就是利用光敏电阻元件这一特性，设计电路将阻值变化转换为电压变化。光敏电阻传感器可以模拟人对环境光线的强度的判断，方便做出与人友好互动的应用。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
电流 : 20 mA
最大功率 : 0.1 W
工作温度 ：-10°C ~ +50°C
输出信号 : 模拟信号
尺寸 ：32 x 23.8 x 7.4 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
当没有光照射时，电阻大小为0.2 MΩ，光敏电阻的信号端（2脚）检测的电压接近0。随着光照强度增大，光线传感器的电阻值越来越小，所以信号端能检测到的电压越来越大。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 光敏电阻传感器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_15_photoresistance.py**"。
```python
### 导入引脚、ADC和DAC模块
from machine import ADC,Pin,DAC
import time
### 开启并配置ADC，量程为0-3.3V
adc=ADC(Pin(34))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_12BIT)
### 每0.1秒读取一次ADC值，将ADC值转换为DAC值输出
### 并将这些数据打印到“Shell”
try:
while True:
adcVal=adc.read()
dacVal=adcVal//16
voltage = adcVal / 4095.0 * 3.3
print("ADC Val:",adcVal,"DACVal:",dacVal,"Voltage:",voltage,"V")
time.sleep(0.1)
except:
pass
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，“Shell”窗口打印出光敏传感器的ADC值、DAC值和电压值。光照越强，可以看到ADC值，DAC值和电压值越大。
---
1.8 代码说明
此课程代码与第十三课代码类似，这里就不多做介绍了。
---
### 第十六课 NTC-MF52AT模拟温度传感器
1.1 项目介绍
在这个套件中，有一个Keyes NTC-MF52AT模拟温度传感器，它的原理与光敏电阻传感器类似，只是感应的器件不同。将传感器信号端接到ESP32主板模拟口，可以读出对应的ADC值，电压值和温度值。我们可以利用ADC值，输出电压值，通过特定公式，计算出当前环境的温度。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
电流 : 20 mA
最大功率 : 0.1 W
工作温度 ：-10°C ~ +50°C
输出信号 : 模拟信号
尺寸 ：32 x 23.8 x 7.4 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
Keyes NTC-MF52AT模拟温度传感器主要由NTC-MF52AT热敏电阻元件组成。NTC-MF52AT热敏电阻元件能够感知周边环境温度的变化，随着温度的升高，热敏电阻的阻值降低，4.7K电阻两端的电压上升，从而引起信号端S的电压变化。
**NTC 热敏电阻温度计算公式：Rt = R * EXP( B * (1/T1-1/T2) ) 。**
其中，T1和T2指的是K度，即开尔文温度。K度=273.15(绝对温度)+摄氏度。
Rt 是热敏电阻在周围温度为T1（当前温度）时的电阻值。
R是热敏电阻在周围温度为T2常温（常温取25℃）时的标称阻值。参考规格书可知我们用的NTC-MF52AT模拟温度传感器在 25℃ 下热敏电阻的零功率电阻值为10KΩ ± 5%（即R=10K），T2=(273.15+25) 。
B值是热敏电阻的重要参数，为材料常数，在25℃下测得。参考规格书可知B值为 3950±1%。
EXP() 是e^()，e的n次方。
通过转换可以得到温度T1与电阻Rt的关系：T1=1 / (ln(Rt/R) /B+1/T2) ，这里可以将ln换算成log，即T1=1/ ( log(Rt/R)/B + 1/T2 ) 。
那么我们唯一需要知道的就是Rt的值。回到上面的原理图，设热敏电阻两端电压为VRt，固定的 R1电阻两端的电压为VR，由电阻分压知识VR/VRt = R1/Rt可以知道：Rt = R1 *(3.3-VR)/VR 。而我们实际得到的VR是转换后的ADC值，需要转换成电压值，即VR = adcValue / 4095.0 * 3.3。
**注意**：计算出来的温度是开尔文温度，因此需要减去K值，对应的摄氏温度 t = T1 - 273.15，同时加上0.5的误差矫正。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | --------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | NTC-MF52AT模拟温度传感器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_16_temperature.py**"。
```python
from machine import Pin, ADC
import time
import math
#Set ADC
adc=ADC(Pin(34))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_12BIT)
try:
while True:
adcValue = adc.read()
voltage = adcValue / 4095 * 3.3
Rt =(3.3-voltage) / voltage * 4700
tempK = (1 / (1 / (273.15+25) + (math.log(Rt/10000)) / 3950))
tempC = (tempK - 273.15) + 0.5
print("ADC value:",adcValue," Voltage:",voltage,"V"," Temperature: ",tempC,"C");
time.sleep(1)
except:
pass
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，“Shell”窗口打印出热敏传感器当前所处环境下的ADC值、电压值和温度值。
---
1.8 代码说明
| 代码 | 说明 |
| ------------------------------------------------------------ | ------------------------------------------------------------ |
| voltage = adcValue / 4095 * 3.3 | 将R1电阻两端转换后的ADC值转换成电压值，数据类型为单精度浮点型。 |
| Rt =(3.3-voltage) / voltage * 4700 | 计算热敏电阻在当前温度下的电阻值。 |
| tempK = (1 / (1 / (273.15+25) + (math.log(Rt/10000)) / 3950)) | 计算当前环境的K度。 |
---
### 第十七课 薄膜压力传感器
1.1 项目介绍
在这个套件中，有一个Keyes 薄膜压力传感器，薄膜压力传感器是基于新型纳米压敏材料辅以舒适杨式模量的超薄薄膜衬底一次性贴片而成，兼具防水和压敏双重功能。
通过采集模块上S端模拟信号，判断压力大小。ADC值、DAC值和电压值越小，压力越大；并在“Shell”窗口上显示测试结果。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
电流 : 20 mA
最大功率 : 0.1W
量程 : 0-5KG
响应点 : 150g
重复性 : ＜±9.7%（60%负载）
一致性 : ±10%
耐久性 : ＞100万次
初始电阻 : 大于10MΩ(无负载)
响应时间 : ＜1ms
恢复时间 : ＜15ms
工作温度 ：-10°C ~ +50°C
输出信号 : 模拟信号
尺寸 ：32 x 23.8 x 7.4 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
当传感器感知到外界压力时，传感器的电阻值发生变化。Keyes 薄膜压力传感器使用LM321运算放大器芯片将传感器感知到的压力变化的压力信号转换成相应变化强度的电信号输出。这样就可以通过检测电压信号变化得知压力变化情况。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 薄膜压力传感器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_17_film pressure\.py**"。
```python
#导入引脚、ADC和DAC模块
from machine import ADC,Pin,DAC
import time
#开启并配置ADC，量程为0-3.3V
adc=ADC(Pin(34))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_12BIT)
### 每0.1秒读取一次ADC值，将ADC值转换为DAC值输出
### 并将这些数据打印到“Shell”
try:
while True:
adcVal=adc.read()
dacVal=adcVal//16
voltage = adcVal / 4095.0 * 3.3
print("ADC Val:",adcVal,"DACVal:",dacVal,"Voltage:",voltage,"V")
time.sleep(0.1)
except:
pass
```
---
1.7 实验结果
为了使实验数据最精准，请将薄膜压力传感器尽量平放。按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。
代码开始执行，"Shell"窗口打印出薄膜压力传感器的ADC值、DAC值和电压值。用手按压薄膜时，随着力量的增大，可以看到ADC值，DAC值和电压值逐渐变小。
---
1.8 代码说明
此课程代码与第十三课代码类似，这里就不多做介绍了。
---
### 第十八课 摇杆模块
1.1 项目介绍
你看过游戏手柄吗？游戏手柄上有按键，还有摇杆。摇杆是什么工作原理呢？在我们这个套件中，就有一个Keyes 摇杆模块，它的主要元件是PS2手柄摇杆。控制时，我们需要将模块的X端口和Y端口连接至单片机的模拟口。B端口连接至单片机数字口，V端口接至单片机电源输出端（3.3-5V），GND接单片机GND。通过读取两个模拟值和一个数字口的高低电平情况，可以判断模块上摇杆的工作状态。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
电流 : 50 mA
最大功率 : 0.25 W
输出信号 : 信号端X、Y 模拟电压输出
信号端B : 数字电平输出
工作温度 ：-10°C ~ +50°C
控制信号 : 数字信号
尺寸 ：47.6 x 23.8 x 34.5 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 5pin防反接口
---
1.3 模块原理图
其实它的原理非常简单，内部相当于两个可调电位器（左右和上下）和一个按键。按键没有按下时被R1下拉为低电平，按下时接通VCC即为高电平，与我们前面学习过的按键模块的电平值是相反的。摇动摇杆时内部的电位器就会根据摇杆的摇动调节，从而输出不同的电压，可以读取到模拟值。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 摇杆模块 x1 | XH2.54-5P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_18_joystick.py**"。
```python
from machine import Pin, ADC
import time
#初始化摇杆模块(ADC功能)
rocker_x=ADC(Pin(34))
rocker_y=ADC(Pin(35))
button_z=Pin(13,Pin.IN,Pin.PULL_UP)
### 设置两个ADC通道的电压采集范围为0-3.3V，
### 并且采集的数据宽度为0-4095
rocker_x.atten(ADC.ATTN_11DB)
rocker_y.atten(ADC.ATTN_11DB)
rocker_x.width(ADC.WIDTH_12BIT)
rocker_y.width(ADC.WIDTH_12BIT)
### 在代码中，将Z_Pin配置为上拉输入模式
### 在loop()中，使用Read()读取X轴和Y轴的值
### 并使用value()读取Z轴的值，然后显示它们
while True:
print("X,Y,Z:",rocker_x.read(),",",rocker_y.read(),",",button_z.value())
time.sleep(0.5)
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，“Shell”窗口将打印出当前摇杆X轴和Y轴对应的模拟值以及Z轴对应的数字值，移动摇杆或按下它将改变“Shell”窗口中的模拟值和数字值。当按下摇杆时，Z值为1；未按下摇杆时，Z值为0。X值从左到右由0增长到4095。Y值从下到上由0增长到4095。
在X轴上移动摇杆，使数据从小到大。
在Y轴上移动摇杆，使数据从小到大。
按下摇杆。
---
1.8 代码说明
| 代码 | 说明 |
| ----------------------------------- | -------------------------- |
| button_z=Pin(13,Pin\.IN,Pin.PULL_UP) | 将引脚设置为输入上拉模式。 |
---
### 第十九课 SK6812 RGB
1.1 项目介绍
前面学习了插件RGB模块，利用PWM信号对模块的三个引脚进行调色。我们这个套件中，还有一个Keyes 6812 RGB模块。SK6812 RGB 模块驱动原理与插件RGB模块的驱动原理不相同，只需要一个引脚控制。这是一个集控制电路与发光电路于一体的智能外控LED光源。每个LED原件其外型与一个5050LED灯珠相同，每个元件即为一个像素点，我们这个模块上有四个灯珠即四个像素点。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
最大功率 : 1W
光源 : SMD 5050 RGB
IC型号 : 4颗/WS2811
灰度等级 : 256级
发光角度 : 180°
发光颜色 : 可以通过控制器调为白，红，黄，蓝，绿,等
工作温度 ：-10°C ~ +50°C
尺寸 ：32 x 23.8 x 7.4 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
从原理图中我们可以看出，这四个像素点灯珠串联。其实不论多少个灯珠串联，我们都可以用一个引脚控制其中任意一个灯让它显示任意一种颜色。像素点内部包含了智能数字接口数据锁存信号整形放大驱动电路，还包含有高精度的内部振荡器和12V高压可编程定电流控制部分，有效保证了像素点光的颜色高度一致。
数据协议采用单线归零码的通讯方式，像素点在上电复位以后，S端接受从控制器传输过来的数据，首先送过来的24bit数据被第一个像素点提取后，送到像素点内部的数据锁存器。这个6812RGB通讯协议与驱动已经在底层封装好了，我们直接调用函数的接口就可以使用。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 6812 RGB模块 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_19_Sk6812_RGB.py**"。
```python
#导入Pin, neopiexl和time模块
from machine import Pin
import neopixel
import time
#定义连接到新像素的引脚和led的数量
pin = Pin(4, Pin.OUT)
np = neopixel.NeoPixel(pin, 4)
#亮度:0 - 255
brightness=100
colors=[[brightness,0,0], #红
[0,brightness,0], #绿
[0,0,brightness], #蓝
[brightness,brightness,brightness], #白
[0,0,0]] #关闭
#嵌套两个for循环，使模块反复显示红、绿、蓝、白、OFF五种状态
while True:
for i in range(0,5):
for j in range(0,4):
np[j]=colors[i]
np.write()
time.sleep_ms(50)
time.sleep_ms(500)
time.sleep_ms(500)
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，可以看到模块上的4个RGB LED一个接一个地填充红色、绿色、蓝色、白色。
---
1.8 代码说明
| 代码 | 说明 |
| ------------------------------ | ---------------------------------------------- |
| pin = Pin(4, Pin.OUT) | 定义引脚号。 |
| np = neopixel.NeoPixel(pin, 4) | 灯珠的数量，板子上灯珠为4颗，所以这里设置为4。 |
| brightness=100 | 亮度设置，255最亮。 |
---
### 第二十课 旋转编码器模块计数
1.1 项目介绍
在这个套件中，有一个Keyes 旋转编码器模块，也叫开关编码器、旋转编码器。此款编码器有20脉冲20定位点、15脉冲30定位点两种。编码器主要用于汽车电子、多媒体音响、仪器仪表、家用电器、智能家居、计算机周边、医疗器械等领域。主要用于频率调节、亮度调节、温度调节、音量调节的参数控制等。
---
1.2 模块参数
工作电压 : DC 5V
电流 : 20 mA
最大功率 : 0.1 W
工作温度 ：-10°C ~ +50°C
控制信号 : 数字信号
尺寸 ：32 x 23.8 x 30.6 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 5pin防反接口
---
1.3 模块原理图
增量式编码器是将位移转换成周期性的电信号，再把这个电信号转变成计数脉冲，用脉冲的个数表明位移的巨细。Keyes 旋转编码器模块采用的是20脉冲旋转编码器元件，它可以通过旋转计数正方向和反方向转动过程中输出脉冲的次数，这种转动计数是没有限制的，复位到初始状态，即从0开始计数。
旋转编码器提供两种交互方式：
- **按钮** 单击旋钮以按下按钮。按下时，按钮将 SW 引脚与 GND 引脚连接，也就是SW引脚的电平为低电平。
- **旋转** 每次旋转旋钮时，会在 DT 和 CLK 引脚上产生一个 LOW 信号。
- 顺时针旋转会导致 CLK 引脚首先变低，然后 DT 引脚也变低。
- 逆时针旋转会导致 DT 引脚先变低，然后 CLK 引脚变低。
两个引脚将在几毫秒内返回高电平。如下图所示：
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 旋转编码器模块 x1 | XH2.54-5P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
上传代码前先添加库。打开Thonny，在文件管理框单击“**此电脑**”，双击“**（D:）**”，然后双击展开“**代码**”文件夹。展开“**20 Rotary encoder counting**”文件夹，右键单击“**rotary\.py**”，选择“**上传到/**”，等待被上传到ESP32。然后继续右键单击“**rotary_irq_rp2.py**”，选择“**上传到/**”，等待被上传到ESP32。
上传完成后双击打开代码文件“**lesson_20_Rotary_encoder_counting.py**”。
```python
import time
from rotary_irq_rp2 import RotaryIRQ
from machine import Pin
SW=Pin(16,Pin.IN,Pin.PULL_UP)
r = RotaryIRQ(pin_num_clk=14,
pin_num_dt=27,
min_val=0,
reverse=False,
range_mode=RotaryIRQ.RANGE_UNBOUNDED)
val_old = r.value()
while True:
try:
val_new = r.value()
if SW.value()==0 and n==0:
print("Button Pressed")
print("Selected Number is : ",val_new)
n=1
while SW.value()==0:
continue
n=0
if val_old != val_new:
val_old = val_new
print('result =', val_new)
time.sleep_ms(50)
except KeyboardInterrupt:
break
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，顺时针旋转编码器，“Shell”窗口打印出来的数据**减小**；逆时针旋转编码器，“Shell”窗口打印出来的数据**增大**；按下编码器中间按键，“Shell”窗口打印“**Button Pressed** **Selected Number is :（当前值)**”。
---
1.8 代码说明
| 代码 | 说明 |
| ---------------- | ------------------------------------------------------------ |
| try:...except... | python语言异常捕捉处理语句，try执行代码，except发生异常时执行的代码。 |
| r.value() | 返回编码器的值。 |
---
### 第二十一课 舵机的控制原理
1.1 项目介绍
舵机是一种位置伺服的驱动器，主要是由外壳、电路板、无核心马达、齿轮与位置检测器所构成。舵机有很多规格，但所有的舵机都有外接三根线。由于舵机品牌不同，颜色也会有所差异，我们实验用到的这款舵机分别用棕、红、橙三种颜色进行区分，棕色为接地线，红色为电源正极，橙色为信号线。
舵机分为360度舵机、180度舵机和90度舵机，我们实验用到的这款舵机为90度舵机，但是它转动的角度范围最大接近180度，所以我们也可把它当做180度舵机使用，控制原理都是一样的。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
工作温度 ：-10°C ~ +50°C
尺寸 ：32.25 x 12.25 x 30.42 mm
接口 ：间距为2.54 mm 3pin接口
---
1.3 模块原理图
舵机的控制信号是周期为20ms （50Hz）的PWM（脉冲宽度调制）信号。
舵机的转动的角度是通过调节PWM信号的占空比来实现的，一般在 0.5ms ~ 2.5ms 的范围内去控制，总间隔为 2ms，相对应舵盘的位置为0度 ~ 180度，呈线性变化。当脉冲宽度为 1.5ms 时，舵机旋转至中间角度，大于 1.5ms 时舵机旋转角度增大，小于 1.5ms 时舵机旋转角度减小。
也就是说，舵机的控制需要单片机产生一个周期为20ms的脉冲信号，以0.5ms到2.5ms的高电平来控制舵机转动的角度。具体脉冲参数下图所示：
注意，由于舵机品牌不同，对于同一信号，不同品牌的舵机旋转的角度也会有所不同。
---
1.4 在线运行组件
|  |  |  |
| ------------------------ | -------------------- | --------------------- |
| ESP32 Plus主板 x1 | 9G 180度数字舵机 x1 | USB线 x1 |
---
1.5 实验
1.5.1 实验①：
（1）实验接线图
（2）在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_21_Servo_test1.py**"。
```python
from machine import Pin, PWM
import time
pwm = PWM(Pin(4))
pwm.freq(50)
'''
Duty cycle corresponding to the Angle
0°----2.5%----25
45°----5%----51.2
90°----7.5%----77
135°----10%----102.4
180°----12.5%----128
'''
angle_0 = 25
angle_90 = 77
angle_180 = 128
while True:
pwm.duty(angle_0)
time.sleep(1)
pwm.duty(angle_90)
time.sleep(1)
pwm.duty(angle_180)
time.sleep(1)
```
（3）实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，舵机由0度转到90度，停顿1秒；再转到180度，停顿1秒；然后回到0度，停顿1秒，循环转动。
单击或按Ctrl+C退出程序。
---
1.5.2 实验②：
（1）实验接线图
（2）在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_21_Servo_test2.py**"。
```python
from utime import sleep
from machine import Pin
from machine import PWM
pwm = PWM(Pin(4))#舵机销连接GP4
pwm.freq(50)#20ms周期，所以频率为50Hz
'''
Duty cycle corresponding to the Angle
0°----2.5%----25
45°----5%----51.2
90°----7.5%----77
135°----10%----102.4
180°----12.5%----128
'''
### 设置伺服旋转角度
def setServoCycle (position):
pwm.duty(position)
sleep(0.01)
### 将旋转角度转换为占空比
def convert(x, i_m, i_M, o_m, o_M):
return max(min(o_M, (x - i_m) * (o_M - o_m) // (i_M - i_m) + o_m), o_m)
while True:
for degree in range(0, 180, 1):#伺服电机从0到180
pos = convert(degree, 0, 180, 20, 150)
setServoCycle(pos)
for degree in range(180, 0, -1):#伺服电机从180到0
pos = convert(degree, 0, 180, 20, 150)
setServoCycle(pos)
```
（3）实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，舵机在0度 ~ 180度之间来回转动，每15ms转动一度。
---
1.6 代码说明
| 代码 | 说明 |
| -------------------------------- | ------------------------------------------------------------ |
| pwm.duty(angle_0) | 根据信号脉宽的角度换算成占空比，公式为：2.5+角度/180*10 ，以ESP32的 PWM 引脚解析度为 2^10 = 1024，换算成 0 度时，其占空比值为 1024 * 2.5% = 25.6 ，当角度为180度时，其占空比值为1024 * 12.5% = 128，这两个值会跟程序有关，考虑到误差及转动角度，将占空比定在10与150 之间，可以让舵机顺利转动0~180度。 |
| convert(degree, 0, 180, 20, 150) | 传进来一个需要转动的角度值为degree，然后这个值的范围是0度到180度，我们要映射的占空比范围为20到150，即把0到180转到了10到150然后被返回了，返回的数据类型为整型，余数会被截断，不进行四舍五入或平均。 |
---
### 第二十二课 超声波传感器的原理
1.1 项目介绍
蝙蝠和某些海洋动物都能够利用高频率的声音进行回声定位或信息交流。它们能通过口腔或鼻腔把从喉部产生的超声波发射出去，利用折回的声波来定向，并判定附近物体的位置、大小以及是否在移动。超声波是一种频率高于20000赫兹的声波，它的方向性好，穿透能力强，易于获得较集中的声能，在水中传播距离远，可用于测距、测速、清洗、焊接、碎石、杀菌消毒等。在医学、军事、工业、农业上有很多的应用。超声波因其频率下限大于人的听觉上限而得名。科学家们将每秒钟振动的次数称为声音的频率，它的单位是赫兹(Hz)。
在这个套件中，有一个HC-SR04超声波传感器，它可以发送出一种频率很高的人类无法听到的超声波信号，这些超声波的信号碰到障碍物，就会立刻反射回来。在接收到返回的信息之后，根据发射信号和接收信号的时间差，计算出传感器和障碍物的详细距离，和蝙蝠飞行的原理一样。
---
1.2 模块参数
超声波传感器工作电压 : DC 5V
超声波传感器工作电流 : 15 mA
超声波传感器工作频率 : 40 Hz
超声波传感器射程范围 : 2 cm ~ 4 m
超声波传感器测量角度 : <= 15度
超声波传感器输入触发信号 : 10 uS 的TTL脉冲
超声波传感器输出回响信号 : 输出TTL电平信号与射程成正比
工作温度 ：-10°C ~ +50°C
超声波传感器尺寸 ：45.5 x 26.7 x 17.6 mm
超声波转接板模块尺寸 ：32 x 23.8 x 11.85 mm
超声波转接板模块定位孔大小：直径为 4.8 mm
超声波转接板模块接口 ：间距为2.54 mm 4pin防反接口
---
1.3 模块原理图
最常用的超声测距的方法是回声探测法。当有脉冲电压触发时（单片机给Trig引脚发送高电平），超声波发射器探头里的晶片就会振动，继而产生超声波。在超声波发射时刻的同时计数器开始计时，超声波在空气中传播，途中碰到障碍物面阻挡就立即反射回来（Echo引脚发送高电平信号给单片机），超声波接收器收到反射回的超声波就立即停止计时。
超声波是一种声波，其声速V与温度有关。一般情况下超声波在空气中的传播速度为340m/s，根据计时器记录的时间t，就可以计算出超声波探头发射点距障碍物面的距离s，即：s=340t/2 。
HC-SR04超声波测距模块可提供范围为2厘米至4米的非接触式距离感测功能，测距精度可达高到3mm。超声波传感器包括超声波发射器、超声波接收器与控制电路。其基本工作原理：
(1)采用IO口Trig触发测距，给至少10us的高电平信号;
(2)模块自动发送8个40khz的方波，自动检测是否有信号返回；
(3)有信号返回，通过IO口Echo输出一个高电平，高电平持续的时间就是超声波从发射到返回的时间。
---
1.4 实验组件
|  |  |  |  |  |
| ------------------------ | ------------------------ | ---------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 超声波转接模块 x1 | HC-SR04 超声波传感器 x1 | XH2.54-4P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_22_ultrasonic.py**"。
```python
from machine import Pin
import time
### 定义超声波测距模块的控制引脚
Trig = Pin(13, Pin.OUT, 0)
Echo = Pin(12, Pin.IN, 0)
distance = 0 # 将初始距离定义为0
soundVelocity = 340 #Set the speed of sound.
### getDistance()函数用于驱动超声波模块测量距离，
### 三角脚保持高电平10us以启动超声波模块
### Echo.value()用于读取超声波模块Echo引脚的状态，
### 然后使用时间模块的时间戳函数计算Echo的持续时间
### 引脚的高电平，根据时间计算测量距离并返回值。
def getDistance():
Trig.value(1)
time.sleep_us(10)
Trig.value(0)
while not Echo.value():
pass
pingStart = time.ticks_us()
while Echo.value():
pass
pingStop = time.ticks_us()
pingTime = time.ticks_diff(pingStop, pingStart) // 2
distance = int(soundVelocity * pingTime // 10000)
return distance
### 延时2秒，等待超声波模块稳定
### 打印每500毫秒从超声波模块获得的数据
time.sleep(2)
while True:
time.sleep_ms(500)
distance = getDistance()
print("Distance: ", distance, "cm")
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，放置障碍物在超声波传感器探头前感应，"Shell"窗口打印出超声波传感器与障碍物之间的距离值。
---
### 第二十三课 红外遥控与接收
1.1 项目介绍
红外线遥控是目前使用最广泛的一种通信和遥控手段。因红外线遥控装置具有体积小、功耗低、功能强、成本低等特点，录音机、音响设备、空凋机以及玩具等其它小型电器装置上纷纷采用红外线遥控。红外遥控的发射电路是采用红外发光二极管发出经过调制的红外光波；红外接收电路由红外接收二极管、三极管或硅光电池组成，它们将红外发射器发射的红外光转换为相应的电信号，再送到后置放大器。
Keyes 红外接收模块选择的是VS1838B红外接收传感器元件，该元件是集接收、放大、解调一体的器件，内部IC就已经完成了解调，输出的就是数字信号。它可接收标准38KHz调制的遥控器信号。
---
1.2 模块参数
工作电压 : DC 3.3 ~ 5V
电流 : 50 mA
最大功率 : 0.25 W
工作温度 ：-10°C ~ +50°C
控制信号 : 数字信号
尺寸 ：32 x 23.8 x 10.8 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
红外遥控系统的主要部分为调制、发射和接收。红外遥控是以调制的方式发射数据，就是把数据和一定频率的载波进行“与”操作，这样既可以提高发射效率又可以降低电源功耗。调制载波频率一般在30khz到60khz之间，大多数使用的是38kHz，占空比1/3的方波。红外接收的信号端加上了4.7K的上拉电阻R3，工作时，首先等待检测低电平，接收到信号后，信号端立即由高电平转为低电平。
---
1.4 实验组件
|  |  |  |  |  |
| ------------------------ | ------------------------ | -------------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 红外接收模块 x1 | Keyes 遥控器 x1 | XH2.54-3P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_23_IR_receiver.py**"。
```python
import utime
from machine import Pin
ird = Pin(4,Pin.IN)
act = {"1": "LLLLLLLLHHHHHHHHLHHLHLLLHLLHLHHH","2": "LLLLLLLLHHHHHHHHHLLHHLLLLHHLLHHH","3": "LLLLLLLLHHHHHHHHHLHHLLLLLHLLHHHH",
"4": "LLLLLLLLHHHHHHHHLLHHLLLLHHLLHHHH","5": "LLLLLLLLHHHHHHHHLLLHHLLLHHHLLHHH","6": "LLLLLLLLHHHHHHHHLHHHHLHLHLLLLHLH",
"7": "LLLLLLLLHHHHHHHHLLLHLLLLHHHLHHHH","8": "LLLLLLLLHHHHHHHHLLHHHLLLHHLLLHHH","9": "LLLLLLLLHHHHHHHHLHLHHLHLHLHLLHLH",
"0": "LLLLLLLLHHHHHHHHLHLLHLHLHLHHLHLH","Up": "LLLLLLLLHHHHHHHHLHHLLLHLHLLHHHLH","Down": "LLLLLLLLHHHHHHHHHLHLHLLLLHLHLHHH",
"Left": "LLLLLLLLHHHHHHHHLLHLLLHLHHLHHHLH","Right": "LLLLLLLLHHHHHHHHHHLLLLHLLLHHHHLH","Ok": "LLLLLLLLHHHHHHHHLLLLLLHLHHHHHHLH",
"*": "LLLLLLLLHHHHHHHHLHLLLLHLHLHHHHLH","#": "LLLLLLLLHHHHHHHHLHLHLLHLHLHLHHLH"}
def read_ircode(ird):
wait = 1
complete = 0
seq0 = []
seq1 = []
while wait == 1:
if ird.value() == 0:
wait = 0
while wait == 0 and complete == 0:
start = utime.ticks_us()
while ird.value() == 0:
ms1 = utime.ticks_us()
diff = utime.ticks_diff(ms1,start)
seq0.append(diff)
while ird.value() == 1 and complete == 0:
ms2 = utime.ticks_us()
diff = utime.ticks_diff(ms2,ms1)
if diff > 10000:
complete = 1
seq1.append(diff)
code = ""
for val in seq1:
if val < 2000:
if val < 700:
code += "L"
else:
code += "H"
# print(code)
command = ""
for k,v in act.items():
if code == v:
command = k
if command == "":
command = code
return command
while True:
command = read_ircode(ird)
print(command)
utime.sleep(0.5)
```
---
1.7 实验结果
Keyes 遥控器上每一个按键都对应着一个按键值，如下图所示。
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行。
找到红外遥控器，拔出绝缘片。对准红外接收模块的红外接收传感器的接收头，按下遥控器任意按键，接收到信号后，“Shell”窗口打印出当前接收到的按键值对应的按键，同时，红外接收传感器上的LED会闪烁。
---
### 第二十四课 DS1307时钟模块
1.1 项目介绍
这个模块主要用到的芯片是美国DALLAS公司推出的I2C总线接口实时时钟芯片DS1307，它可独立于CPU工作，不受CPU主晶振及其电容的影响；计时准确，月累积误差一般小于10秒。此芯片还具有主电源掉电情况下的时钟保护电路，DS1307的时钟靠后备电池维持工作，拒绝CPU对其读出和写入访问。同时还具有备用电源自动切换控制电路，因而可在主电源掉电和其它一些恶劣环境场合中保证系统时钟的定时准确性。DS1307具有产生秒、分、时、日、月、年等功能，且具有闰年自动调整功能。同时，DS1307芯片内部还集成有一定容量、具有掉电保护特性的静态RAM，可用于保存一些关键数据。
---
1.2 模块参数
中断类型 : 全天时间
存储器容量 : 56 bytes
存储器类型 : RAM
接口类型 : Serial, I2C
时钟频率 : 32.768kHz
特点 : 方波输出
电压, Vcc 最大 : 5V
电源电压 最小 : 4.5V
类型 : RTC
工作温度 ：-10°C ~ +50°C
通讯方式 ：I2C通讯
尺寸 ：47.6 x 23.8 x 7.4 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 3pin防反接口
---
1.3 模块原理图
DS1307 把8 个寄存器和56 字节的RAM 进行了统一编址，记录年、月、日、时、分、秒及星期; AM、PM 分别表示上午和下午; 56 个字节的NVRAM存放数据; 2线串口; 可编程的方波输出;电源故障检测及自动切换电路;电池电流小于500nA。
主要引脚定义如下：
| DS1307引脚 | 定义 |
| ---------- | -------------------- |
| X1、X2 | 32.768kHz 晶振接入端 |
| VBAT | +3V 电池电压输入 |
| VCC | 电源电压 |
| SQW | 方波驱动器 |
| SCL | 串行时钟 |
| SDA | 串行数据 |
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ----------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes DS1307时钟传感器模块 x1 | XH2.54-4P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_24_DS1307.py**"。
```python
from machine import I2C, Pin
import time
### 配置I2C总线
i2c = I2C(scl=Pin(22), sda=Pin(21), freq=400000)
#DS1307写入时间已启用
year0 = int(input("Year : "))
month0 = int(input("month (Jan --> 1 , Dec --> 12): "))
day0 = int(input("day : "))
weekday0 = int(input("weekday (1 --> monday , 2 --> Tuesday ... 0 --> Sunday): "))
hours0 = int(input("hour (24 Hour format): "))
minutes0 = int(input("minute : "))
seconds0 = int(input("second : "))
seconds = ((seconds0 // 10) << 4) + (seconds0 % 10)
minutes = ((minutes0 // 10) << 4) + (minutes0 % 10)
hours = ((hours0 // 10) << 4) + (hours0 % 10)
weekday = weekday0 % 7
day = ((day0 // 10) << 4) + (day0 % 10)
month = ((month0 // 10) << 4) + (month0 % 10)
year = ((year0 - 2000) // 10 << 4) + (year0 - 2000) % 10
#将时间写入DS1307
i2c.writeto_mem(0x68, 0x00, bytes([seconds, minutes, hours, weekday, day, month, year]))
while True:
# 发送命令读取当前时间
i2c.writeto(0x68, bytes([0x00]))
# 从DS1307读取当前时间
data = i2c.readfrom(0x68, 7)
seconds = (data[0] & 0x0f) + ((data[0] & 0x70) >> 4) * 10
minutes = (data[1] & 0x0f) + ((data[1] & 0x70) >> 4) * 10
hours = (data[2] & 0x0f) + (((data[2] & 0x30) >> 4) % 2) * 10
weekday = data[3]
day = (data[4] & 0x0f) + ((data[4] & 0x30) >> 4) * 10
month = (data[5] & 0x0f) + ((data[5] & 0x10) >> 4) * 10
year = (data[6] & 0x0f) + ((data[6] & 0xf0) >> 4) * 10
print('20{:02}/{:02}/{:02} {:02}:{:02}:{:02} {:2}'.format(year, month, day, hours, minutes, seconds,weekday))
time.sleep(1)
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行。
需要在“Shell”窗口**手动输入年、月、日、周、时、分、秒**，设为初始时间，此后每秒刷新一次时间并打印出来。
---
1.8 代码说明
| 代码 | 说明 |
| ------------------------------------------------------------ | ----------------------------------------- |
| i2c = I2C(scl=Pin(22), sda=Pin(21), freq=400000) | 设置I2C的引脚和频率。 |
| i2c.writeto_mem(0x68, 0x00, bytes([seconds, minutes, hours, weekday, day, month, year])) | 将在“Shell”窗口输入的初始时间写入DS1307。 |
---
### 第二十五课 TM1650四位数码管模块
1.1 项目介绍
Keyes TM1650四位数码管模块选用的 0.36 英寸红色共阴4位数码管的驱动芯片是TM1650。TM1650是一种带键盘扫描接口的LED驱动控制专用电路的芯片。内部集成有MCU输入输出控制数字接口、数据锁存器、LED 驱动、键盘扫描等电路。TM1650性能稳定、质量可靠、抗干扰能力强，可适用于24小时长期连续工作的应用场合。TM1650采用两线串行传输协议通讯（注意：该数据传输协议不是标准的I2C协议）。该芯片只需要通过两个引脚与MCU通讯就可以完成数码管的驱动，可以节省MCU引脚资源。
实验中使用Keyes TM1650四位数码管模块时，我们只需要2根信号线即可使单片机控制4位数码管，大大节约了控制板IO口资源。
---
1.2 模块参数
工作电压 : DC 5V
电流 : 100 mA
最大功率 : 0.5 W
数码管显示颜色 : 红色
LED极性 : 共阴
通讯方式 ：2线高速串行接口（CLK,DAT）
工作温度 ：-10°C ~ +50°C
尺寸 ：47.6 x 23.8 x 10.6 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 4pin防反接口
---
1.3 模块原理图
TM1650与MCU之间的通讯采用2线高速串行接口（CLK,DAT），这两个连线分别是数据线DAT和同步时钟线CLK。其中DAT为双向数据传输线，TM1650既用该线从MCU接收数据，也用该线向MCU发送数据。
实验中我们使用封装好的库函数。
如果大家有兴趣也可以接着往下学习了解 1.3.1 TM1650通讯时序格式和 1.3.2 指令集说明，然后再去了解底层的库函数是如何实现的。
1.3.1 TM1650通讯时序格式
TM1650采用下图1 中2线串行传输协议通讯：
（1）开始信号（START）/结束信号(STOP)
开始信号：保持 CLK 为“1”电平，DAT 从“1”跳“0”，认为是开始信号，如上图1的 A 段；
结束信号：保持 CLK 为“1”电平，DAT 从“0”跳“1”，认为是结束信号，如上图1的 E 段；
（2）ACK 信号
如果本次通讯正常，芯片在串行通讯的第 8 个时钟下降沿后，TM1650 主动把 DAT 拉低，直到 CLK 检测到上升沿，DAT 释放为输入状态（对芯片而言）,如上图1的 D 段。
（3） 写“1”和写“0”
写“1”：保持 DAT 为“1”电平，CLK 从“0”跳到“1”,再从“1”跳到“0”，则认为是写入“1” ，如上图 1的 B 段。
写“0”：保持 DAT 为“0”电平，CLK 从“0”跳到“1”,再从“1”跳到“0”，则认为是写入“0” ，如上图 1的 C 段。
（4） 一个字节（8 位）数据传输格式
一个字节数据的传输格式如图上 2，数据发送时 MSB 在前，LSB 在后，即高位先进。微处理器的数据通过 2 线 串行接口和 TM1650 通信，当 CLK 是高电平时，DAT 上的信号必须保持不变；只有 CLK 上的时钟信号为低电平时， DAT 上的信号才能改变。数据输入的开始条件是 CLK 为高电平时，DAT 由高变低；结束条件是 CLK 为高时，DAT 由低电平变为高电平。
（5）写显示操作
ADDRESS：显示地址（68H、6AH、6CH、6EH）；
DATA：显示数据。
（6）完整操作时序
command1：系统命令 48H；
command2：系统参数设置；
ADDRESS：显示地址（68H、6AH、6CH、6EH）；
DATA：显示数据。
备注：
1、设置系统参数和写入显存数据是两个独立的过程，它们之间的顺序不影响实际应用；
2、每次输入系统命令（48H）和系统参数设置命令都会改变系统参数，请特别注意待机指令操作。
1.3.2 指令集说明
（1）数据命令设置
注意：使用的指令是 16 进制 H，输入数据和读取数据都是从高位开始。
所以在代码中我们数据命令设置为 0x48，使用TM1650点亮数码管的功能，而不使用按键扫描的功能。
（2）显示命令设置
注意：在发送上述系统显示命令前需要先输入系统命令48H,如48H+11H=1级亮度开屏显示。
B[7:0] 这里实际是一个字节数据，只是不同位部分代表不同功能。
B[6:4] ：设置数码管亮度。注意，000 最亮。
B[3] ：设置是否显示小数点。
B[0] ：设置数码管的开屏、关屏。
（3） 显存地址
如果要显示小数点，则必须先需要将段模式设置为 8 段输出。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ----------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes TM1650四位数码管模块 x1 | XH2.54-4P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_25_TM1650.py**"。
```python
from machine import Pin
import time
### TM1650的定义
ADDR_DIS = 0x48 #加密模式命令
ADDR_KEY = 0x49 #读键值命令
### 亮度的定义
BRIGHT_DARKEST = 0
BRIGHT_TYPICAL = 2
BRIGHTEST = 7
on = 1
off = 0
### number:0~9
NUM = [0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f]
DIG = [0x6e,0x6c,0x6a,0x68]
DOT = [0,0,0,0]
clkPin = 22
dioPin = 21
clk = Pin(clkPin, Pin.OUT)
dio = Pin(dioPin, Pin.OUT)
DisplayCommand = 0
def writeByte(wr_data):
global clk,dio
for i in range(8):
if(wr_data & 0x80 == 0x80):
dio.value(1)
else:
dio.value(0)
clk.value(0)
time.sleep(0.0001)
clk.value(1)
time.sleep(0.0001)
clk.value(0)
wr_data <<= 1
return
def start():
global clk,dio
dio.value(1)
clk.value(1)
time.sleep(0.0001)
dio.value(0)
return
def ack():
global clk,dio
dy = 0
clk.value(0)
time.sleep(0.0001)
dio = Pin(dioPin, Pin.IN)
while(dio.value() == 1):
time.sleep(0.0001)
dy += 1
if(dy>5000):
break
clk.value(1)
time.sleep(0.0001)
clk.value(0)
dio = Pin(dioPin, Pin.OUT)
return
def stop():
global clk,dio
dio.value(0)
clk.value(1)
time.sleep(0.0001)
dio.value(1)
return
def displayBit(bit, num):
global ADDR_DIS
if(num > 9 and bit > 4):
return
start()
writeByte(ADDR_DIS)
ack()
writeByte(DisplayCommand)
ack()
stop()
start()
writeByte(DIG[bit-1])
ack()
if(DOT[bit-1] == 1):
writeByte(NUM[num] | 0x80)
else:
writeByte(NUM[num])
ack()
stop()
return
def clearBit(bit):
if(bit > 4):
return
start()
writeByte(ADDR_DIS)
ack()
writeByte(DisplayCommand)
ack()
stop()
start()
writeByte(DIG[bit-1])
ack()
writeByte(0x00)
ack()
stop()
return
def setBrightness(b = BRIGHT_TYPICAL):
global DisplayCommand,brightness
DisplayCommand = (DisplayCommand & 0x0f)+(b<<4)
return
def setMode(segment = 0):
global DisplayCommand
DisplayCommand = (DisplayCommand & 0xf7)+(segment<<3)
return
def displayOnOFF(OnOff = 1):
global DisplayCommand
DisplayCommand = (DisplayCommand & 0xfe)+OnOff
return
def displayDot(bit, OnOff):
if(bit > 4):
return
if(OnOff == 1):
DOT[bit-1] = 1;
else:
DOT[bit-1] = 0;
return
def InitDigitalTube():
setBrightness(2)
setMode(0)
displayOnOFF(1)
for _ in range(4):
clearBit(_)
return
def ShowNum(num): #0~9999
displayBit(1,num%10)
if(num < 10):
clearBit(2)
clearBit(3)
clearBit(4)
if(num > 9 and num < 100):
displayBit(2,num//10%10)
clearBit(3)
clearBit(4)
if(num > 99 and num < 1000):
displayBit(2,num//10%10)
displayBit(3,num//100%10)
clearBit(4)
if(num > 999 and num < 10000):
displayBit(2,num//10%10)
displayBit(3,num//100%10)
displayBit(4,num//1000)
InitDigitalTube()
while True:
#displayDot(1,on) # 开或关, DigitalTube.Display(bit,number); bit=1---4 number=0---9
for i in range(0,9999):
ShowNum(i)
time.sleep(0.01)
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，能看到4位数码管显示数字，从0开始，每10毫秒加1，直至加到9999后又从0开始循环。
---
1.8 代码说明
| 代码 | 说明 |
| --------------------------------- | ---------------------------- |
| clearBit(bit) | 清除bit(1~4)位显示。 |
| setBrightness(b = BRIGHT_TYPICAL) | 亮度设置。 |
| DigitalTube.clearBit(b) | 清除位显示。 |
| displayOnOFF(OnOff = 1) | 显示小数点，0为关，1为开。 |
| ShowNum(num) | 显示整数num，范围为0~9999 。 |
---
### 第二十六课 HT16K33_8X8点阵模块
1.1 项目介绍
点阵，多个LED组成的阵列，他们的集合称为“阵”，其中单个单元称为“点”。8X8点阵共由64个发光二极管组成，且每个发光二极管是放置在行线和列线的交叉点上。
第二课我们学习了一个IO口控制一个led，这节课我们来学习用更少的IO口控制更多的led。
---
1.2 模块参数
工作电压 : DC 5V
电流 : 200 mA
最大功率 : 1 W
工作温度 ：-10°C ~ +50°C
通讯方式 ：I2C通讯
I2C通信地址 ：0X70
点阵屏显示颜色 ：蓝色
尺寸 ：32 x 23.8 x 7.4 mm
定位孔大小：直径为 4.8 mm
接口 ：间距为2.54 mm 4pin防反接口
---
1.3 模块原理图
如原理图所示，如果想要点亮第一行第一列的LED灯，只需要将C1置高电平、R1置低电平就可以了。如果我们想让第一行led全部点亮，只需要将R1置为低电平，C1~C8全部置为高电平就可以了。原理非常简单，但是这样设置的话我们总共需要用到16个IO口，非常浪费单片机资源。为了节省IO口不浪费单片机资源，我们特别设计了这个HT16K33_8X8点阵模块，利用HT16K33芯片驱动1个8*8点阵，只需要利用单片机的I2C通信端口就能控制点阵的64个发光二极管。
我们这款Keyes HT16K33_8X8点阵模块已经固定了通信地址，地址为0x70。
---
1.4 实验组件
|  |  |  |  |
| ------------------------ | ---------------------------- | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes HT16K33_8X8点阵模块 x1 | XH2.54-4P 转杜邦线母单线 x1 | USB线 x1 |
---
1.5 模块接线图
---
1.6 在线运行代码
上传代码前先添加库。打开Thonny，在文件管理框单击“**此电脑**”，双击“**（D:）**”，然后双击展开“**代码**”文件夹。展开“**26 HT16K33 dot matrix**”文件夹，右键单击“**ht16k33\py**”，选择“**上传到/**”，等待被上传到ESP32。然后继续右键单击“**ht16k33matrix\.py**”，选择“**上传到/**”，等待被上传到ESP32。
**注意：在上传代码前先接好模块，否则代码可能上传不成功。**
上传完成后双击打开代码文件''**lesson_26_matrix_dot.py**"。
```python
import utime as time
from machine import I2C, Pin, RTC
from ht16k33matrix import HT16K33Matrix
### 常量
DELAY = 0.01
PAUSE = 3
### 初始
if __name__ == '__main__':
i2c = I2C(scl=Pin(22), sda=Pin(21))
display = HT16K33Matrix(i2c)
display.set_brightness(2)
# 在LED上绘制自定义图标
icon = b"\x00\x66\x00\x00\x18\x42\x3c\x00"
display.set_icon(icon).draw()
display.set_angle(0).draw()
time.sleep(PAUSE)
```
---
1.7 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，HT16K33_8X8点阵模块显示“笑脸”图案。
若代码上传成功后点阵屏不显示“笑脸”图案，尝试按一下RESET键。
---
### 第二十七课 按键控制LED灯
1.1 项目介绍
从前面的实验课程中我们学习了按键模块，按下按键我们的单片机读取到低电平，松开按键读取到高电平。在这一实验课程中，我们将按键模块和紫色LED模块组合实验，实现按下按键LED点亮，再次按下按键LED熄灭，再次按下再次点亮的效果。
---
1.2 实验组件
|  |  |  |  |  |
| ------------------------ | ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 单路按键模块 x1 | Keyes 紫色LED模块 x1 | XH2.54-3P 转杜邦线母单线 x2 | USB线 x1 |
---
1.3 实验接线图
---
1.4 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_27_button_control_LED.py**"。
```python
from machine import Pin
import time
led = Pin(12, Pin.OUT) # 从引脚12创建LED对象，设置引脚12输出
button = Pin(13, Pin.IN, Pin.PULL_UP) #从GP13创建按钮对象，设置GP13为输入
#自定义一个函数并将其命名为reverseGPIO()，它将反转LED的输出电平
def reverseGPIO():
if led.value():
led.value(0) #设置led关闭
else:
led.value(1) #设置led开启
try:
while True:
if not button.value():
time.sleep_ms(20)
if not button.value():
reverseGPIO()
while not button.value():
time.sleep_ms(20)
except:
pass
```
---
1.5 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，按下按键，LED点亮，再次按下，LED熄灭。循环进行。
单击或按Ctrl+C退出程序。
---
### 第二十八课 障碍物报警实验
1.1 项目介绍
在前面实验课程中中，我们使用一个输入模块控制另一个输出模块。在这一实验中，我们还是用一个模块控制另一个模块。
生活中，我们可以利用一个检测传感器控制一个有源蜂鸣器响起或者LED点亮，做声光报警设备，如检测磁场（干簧管）、检测倾斜（倾斜模块）等等。这一实验课程中我们将避障传感器和有源蜂鸣器模块组合实验，实现避障传感器检测到障碍物时有源蜂鸣器响起的效果。
---
1.2 实验组件
|  |  |  |  |  |
| ------------------------ | ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 避障传感器 x1 | Keyes 有源蜂鸣器模块 x1 | XH2.54-3P 转杜邦线母单线 x2 | USB线 x1 |
---
1.3 实验接线图
---
1.4 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_28_Avoiding_alarm.py**"。
```python
from machine import Pin
import time
buzzer = Pin(13, Pin.OUT)
sensor = Pin(12, Pin.IN)
while True:
buzzer.value(not(sensor.value()))
time.sleep(0.01)
```
---
1.5 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，当避障传感器检测到障碍物时，避障传感器上SLED灯亮起，同时有源蜂鸣器发出声响；当避障传感器检测不到障碍物时，有源蜂鸣器停止发出声响。
---
### 第二十九课 入侵检测报警器
1.1 项目介绍
上一课实验中我们学习了使用避障传感器检测障碍物进行报警提醒。在这一实验课程中我们将人体红外热释传感器、紫色LED模块和有源蜂鸣器模块组合实验，实现人体红外热释传感器检测到附近有人经过时有源蜂鸣器响起，紫色LED快速闪烁的效果。
---
1.2 实验组件
|  |  |  |
| ------------------------ | ---------------------------- | ------------------------ |
| ESP32 Plus主板 x1 | Keyes 人体红外热释传感器 x1 | Keyes 有源蜂鸣器模块 x1 |
|  |  |  |
| Keyes 紫色LED模块 x1 | XH2.54-3P 转杜邦线母单线 x3 | USB线 x1 |
---
1.3 模块接线图
---
1.4 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_29_PIR_alarm.py**"。
```python
#导入引脚和时间模块
from machine import Pin
import time
### 定义人体红外传感器，led和主动蜂鸣器的引脚
sensor_pir = Pin(12, Pin.IN)
led = Pin(5, Pin.OUT)
buzzer = Pin(13, Pin.OUT)
while True:
if sensor_pir.value():
print("Warning! Intrusion detected！")
buzzer.value(1)
led.value(1)
time.sleep(0.2)
buzzer.value(0)
led.value(0)
time.sleep(0.2)
else:
buzzer.value(0)
led.value(0)
```
---
1.5 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，当人体红外热释传感器检测到附近有人经过时，人体红外热释传感器上的红灯灭，有源蜂鸣器发出警报，紫色LED灯快速闪烁，“Shell”窗口打印出“**Warning! Intrusion detected！**”。
单击或按Ctrl+C退出程序。
---
### 第三十课 旋转编码器控制RGB
1.1 项目介绍
在第二十课的实验中我们学习了使用旋转编码器计数。在这一实验课程中我们将旋转编码器模块和共阴RGB模块组合实验，通过旋转编码器计数的结果，控制RGB模块上LED显示不同的颜色。
---
1.2 实验组件
|  |  |  |
| ---------------------------- | ---------------------------- | ------------------------ |
| ESP32 Plus主板 x1 | Keyes 旋转编码器模块 x1 | Keyes 共阴RGB模块 x1 |
|  |  |  |
| XH2.54-5P 转杜邦线母单线 x1 | XH2.54-4P 转杜邦线母单线 x1 | USB线 x1 |
---
1.3 模块接线图
---
1.4 在线运行代码
上传代码前先添加库。打开Thonny，在文件管理框单击“**此电脑**”，双击“**（D:）**”，然后双击展开“**代码**”文件夹。展开“**30 Encoder control RGB**”文件夹，右键单击“**rotary\.py**”，选择“**上传到/**”，等待被上传到ESP32。然后继续右键单击“**rotary_irq_rp2.py**”，选择“**上传到/**”，等待被上传到ESP32。
上传完成后双击打开代码文件''**lesson_30_Encoder_control_RGB.py**"。
```python
import time
from rotary_irq_rp2 import RotaryIRQ
from machine import Pin, PWM
pwm_r = PWM(Pin(32))
pwm_g = PWM(Pin(4))
pwm_b = PWM(Pin(2))
pwm_r.freq(1000)
pwm_g.freq(1000)
pwm_b.freq(1000)
def light(red, green, blue):
pwm_r.duty(red)
pwm_g.duty(green)
pwm_b.duty(blue)
SW=Pin(16,Pin.IN,Pin.PULL_UP)
r = RotaryIRQ(pin_num_clk=14,
pin_num_dt=27,
min_val=0,
reverse=False,
range_mode=RotaryIRQ.RANGE_UNBOUNDED)
while True:
val = r.value()
print(val%3)
if val%3 == 0:
light(1023, 0, 0)
elif val%3 == 1:
light(0, 1023, 0)
elif val%3 == 2:
light(0, 0, 1023)
time.sleep(0.1)
```
---
1.5 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，任意方向旋转编码器，串口监视器打印出对应余数；RGB模块上的LED显示余数对应的颜色：余数0显示红色、余数1显示绿色、余数2显示蓝色。按下旋转编码器，RGB模块上LED保持当前颜色不变。
单击或按Ctrl+C退出程序。
---
### 第三十一课 电位器调节灯光亮度
1.1 项目介绍
从前面的课程实验中我们学习了设计呼吸灯和按键控制LED灯。在这一实验课程中我们尝试将呼吸灯和按键控制LED灯这两个实验现象组合起来，用可调电位器代替按键，实现利用旋转可调电位器读取到的模拟值控制紫色LED亮度的效果。可调电位器模拟值的范围是0 ~ 4095；LED的亮度由PWM值控制，范围为0 ~ 255。
---
1.2 实验组件
|  |  |  |  |  |
| ------------------------ | ------------------------- | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 旋转电位器传感器 x1 | Keyes 紫色LED模块 x1 | XH2.54-3P 转杜邦线母单线 x2 | USB线 x1 |
---
1.3 模块接线图
---
1.4 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_31_adjust_the_light.py**"。
```python
from machine import Pin,PWM,ADC
import time
pwm =PWM(Pin(5,Pin.OUT),1000)
adc=ADC(Pin(34))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_10BIT)
try:
while True:
adcValue=adc.read()
pwm.duty(adcValue)
print(adc.read())
time.sleep_ms(100)
except:
pwm.deinit()
```
---
1.5 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，旋转电位器，可以调节紫色LED的亮度，“Shell”窗口打印出当前PWM的值。
单击或按Ctrl+C退出程序。
---
### 第三十二课 声控灯
1.1 项目介绍
如今智能家居发展迅速，你使用过智能家居当中的智能声控灯吗？当我们跺跺脚或者拍拍手时，智能声控灯自动亮起；当没有声音时，智能声控灯处于熄灭状态。智能声控灯上安装有声音探测传感器，这些传感器将外界声音的大小，转换成对应数值。智能声控灯设置一个临界点，当声音转换后对应的数值超过该临界点时，灯光亮起一段时间。
在这一实验课程中，我们将声音传感器和紫色LED模块组合实验，学习制作一个最简单的智能声控灯。
---
1.2 实验组件
|  |  |  |  |  |
| ------------------------ | ------------------------ | ------------------------ | ---------------------------- | --------------------- |
| ESP32 Plus主板 x1 | Keyes 声音传感器 x1 | Keyes 紫色LED模块 x1 | XH2.54-3P 转杜邦线母单线 x2 | USB线 x1 |
---
1.3 模块接线图
---
1.4 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_32_sound_controlled_lights.py**"。
```python
from machine import ADC, Pin
import time
### 开启并配置ADC，量程为0-3.3V
adc=ADC(Pin(34))
adc.atten(ADC.ATTN_11DB)
adc.width(ADC.WIDTH_12BIT)
led = Pin(5,Pin.OUT)
while True:
adcVal=adc.read()
if adcVal > 400:
led.value(1)
print(adcVal, "led on")
time.sleep(3)
else:
led.value(0)
print(adcVal, "led off")
time.sleep(0.1)
```
---
1.5 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，“Shell”窗口打印出声音传感器接收到的声音对应的ADC值，接收到的声音增大时ADC值也增大，当ADC值大于400时，LED模块上LED亮起3秒，然后熄灭。
单击或按Ctrl+C退出程序。
---
### 第三十三课 超声波雷达
1.1 项目介绍
蝙蝠飞行与获取猎物是通过回声定位的。回声定位：某些动物能通过口腔或鼻腔把从喉部产生的超声波发射出去，利用折回的声音来定向，这种空间定向的方法称为回声定位。科学家们从蝙蝠身上得到的启示发明了雷达，即雷达的天线相当于蝙蝠的嘴,而天线发出的无线电波就相当于蝙蝠的超声波,雷达接收电波的荧光屏就相当于蝙蝠的耳朵。
这一课我们就来学习制作一个简易雷达。将HC-SR04 超声波传感器、8002b功放 喇叭模块、共阴RGB模块和TM1650四位数码管模块组合实验，利用距离大小控制功放喇叭模块模块响起对应频率的声音、RGB亮起对应颜色，然后把这个距离显示在四位数码管上。这样就搭建好了一个简易的超声波雷达系统。
---
1.2 实验组件
|  |  |  |
| ---------------------------- | ---------------------------- | ----------------------------- |
| ESP32 Plus主板 x1 | HC-SR04 超声波传感器 x1 | Keyes 超声波转接模块 x1 |
|  |  |  |
| Keyes 8002b功放 喇叭模块 x1 | Keyes 共阴RGB模块 x1 | Keyes TM1650四位数码管模块 x1 |
|  |  |  |
| XH2.54-3P 转杜邦线母单线 x1 | XH2.54-4P 转杜邦线母单线 x3 | USB线 x1 |
---
1.3 模块接线图
---
1.4 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_33_Ultrasonic_radar.py**"。
```python
from machine import Pin, PWM
import utime
### TM1650的定义
ADDR_DIS = 0x48 #mode command
ADDR_KEY = 0x49 #read key value command
### 亮度的定义
BRIGHT_DARKEST = 0
BRIGHT_TYPICAL = 2
BRIGHTEST = 7
on = 1
off = 0
### number:0~9
NUM = [0x3f,0x06,0x5b,0x4f,0x66,0x6d,0x7d,0x07,0x7f,0x6f]
DIG = [0x6e,0x6c,0x6a,0x68]
DOT = [0,0,0,0]
clkPin = 22
dioPin = 21
clk = Pin(clkPin, Pin.OUT)
dio = Pin(dioPin, Pin.OUT)
DisplayCommand = 0
def writeByte(wr_data):
global clk,dio
for i in range(8):
if(wr_data & 0x80 == 0x80):
dio.value(1)
else:
dio.value(0)
clk.value(0)
utime.sleep(0.0001)
clk.value(1)
utime.sleep(0.0001)
clk.value(0)
wr_data <<= 1
return
def start():
global clk,dio
dio.value(1)
clk.value(1)
utime.sleep(0.0001)
dio.value(0)
return
def ack():
global clk,dio
dy = 0
clk.value(0)
utime.sleep(0.0001)
dio = Pin(dioPin, Pin.IN)
while(dio.value() == 1):
utime.sleep(0.0001)
dy += 1
if(dy>5000):
break
clk.value(1)
utime.sleep(0.0001)
clk.value(0)
dio = Pin(dioPin, Pin.OUT)
return
def stop():
global clk,dio
dio.value(0)
clk.value(1)
utime.sleep(0.0001)
dio.value(1)
return
def displayBit(bit, num):
global ADDR_DIS
if(num > 9 and bit > 4):
return
start()
writeByte(ADDR_DIS)
ack()
writeByte(DisplayCommand)
ack()
stop()
start()
writeByte(DIG[bit-1])
ack()
if(DOT[bit-1] == 1):
writeByte(NUM[num] | 0x80)
else:
writeByte(NUM[num])
ack()
stop()
return
def clearBit(bit):
if(bit > 4):
return
start()
writeByte(ADDR_DIS)
ack()
writeByte(DisplayCommand)
ack()
stop()
start()
writeByte(DIG[bit-1])
ack()
writeByte(0x00)
ack()
stop()
return
def setBrightness(b = BRIGHT_TYPICAL):
global DisplayCommand,brightness
DisplayCommand = (DisplayCommand & 0x0f)+(b<<4)
return
def setMode(segment = 0):
global DisplayCommand
DisplayCommand = (DisplayCommand & 0xf7)+(segment<<3)
return
def displayOnOFF(OnOff = 1):
global DisplayCommand
DisplayCommand = (DisplayCommand & 0xfe)+OnOff
return
def displayDot(bit, OnOff):
if(bit > 4):
return
if(OnOff == 1):
DOT[bit-1] = 1;
else:
DOT[bit-1] = 0;
return
def InitDigitalTube():
setBrightness(2)
setMode(0)
displayOnOFF(1)
for _ in range(4):
clearBit(_)
return
def ShowNum(num): #0~9999
displayBit(1,num%10)
if(num < 10):
clearBit(2)
clearBit(3)
clearBit(4)
if(num > 9 and num < 100):
displayBit(2,num//10%10)
clearBit(3)
clearBit(4)
if(num > 99 and num < 1000):
displayBit(2,num//10%10)
displayBit(3,num//100%10)
clearBit(4)
if(num > 999 and num < 10000):
displayBit(2,num//10%10)
displayBit(3,num//100%10)
displayBit(4,num//1000)
pwm_r = PWM(Pin(4))
pwm_g = PWM(Pin(32))
pwm_b = PWM(Pin(33))
pwm_r.freq(1000)
pwm_g.freq(1000)
pwm_b.freq(1000)
def light(red, green, blue):
pwm_r.duty(red)
pwm_g.duty(green)
pwm_b.duty(blue)
#超声波测距，单位:厘米
def getDistance(trigger, echo):
# 产生10us方波
trigger.value(0) #事先给一个短的低电平，以确保一个干净的高脉冲;
utime.sleep_us(2)
trigger.value(1)
utime.sleep_us(10)#拉高后，等待10微秒，立即调低
trigger.value(0)
while echo.value() == 0: #建立while循环，检测回波引脚值是否为0，并记录此时的时间
start = utime.ticks_us()
while echo.value() == 1: #建立while循环，检查回波引脚值是否为1，并记录此时的时间
end = utime.ticks_us()
d = (end - start) * 0.0343 / 2 #声波的传播时间x声速(343.2 m/s, 0.0343 cm/微秒)，再除以来回距离2
return d
### 设置引脚
trigger = Pin(13, Pin.OUT)
echo = Pin(12, Pin.IN)
buzzer = PWM(Pin(2))
def playtone(frequency):
buzzer.duty(1000)
buzzer.freq(frequency)
def bequiet():
buzzer.duty(0)
### 主程序
InitDigitalTube()
while True:
distance = int(getDistance(trigger, echo))
ShowNum(distance)
if distance <= 10:
playtone(880)
utime.sleep(0.1)
bequiet()
light(1023, 0, 0)
elif distance <= 20:
playtone(532)
utime.sleep(0.2)
bequiet()
light(0, 0, 1023)
else:
light(0, 1023, 0)
```
---
1.5 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，当超声波传感器检测到障碍物距离范围在10cm 以内时，RGB LED灯亮红色，并将检测到障碍物的距离显示在四位数码管上。同时8002b功放 喇叭模块发出频率较快的声响，起到提示的作用。
当超声波传感器检测到障碍物距离范围在10cm ~ 20cm 以内时，RGB LED灯亮绿色，并将检测到障碍物的距离显示在四位数码管上。同时8002b功放 喇叭模块发出声响，起到提示的作用。
当超声波传感器检测到障碍物距离范围在20cm 以外时，RGB LED灯亮蓝色，并将检测到障碍物的距离显示在四位数码管上。
---
### 第三十四课 红外遥控灯
1.1 项目介绍
在前面实验中，我们学会了点亮或熄灭LED、学会了利用PWM调节灯光的亮度、学会了使用红外接收模块，并将接收到的遥控器对应的键值打印出来。在这一实验课程中，我们将红外接收模块和紫色LED模块组合实验，实现用红外遥控器控制紫色LED的亮灭以及控制紫色LED显示不同亮度。
当红外接收模块接收到红外遥控器的按键值时，通过设置此按键值的输出PWM值实现设置不同LED亮度的效果，控制LED的亮灭也一样。
在这一实验课程中我们使用 “①“、”②“、”③”三个按键来控制紫色LED实现弱亮、正常亮、强亮三种不同亮度。如果想要使用 “OK” 键这一个按键来控制LED亮和灭的两种情况该如何实现呢？这一实验课程我们将学习使用一个新的基本数据类型 —— boolean，来实现同一个按键控制LED亮灭的效果。
**boolean 数据类型**，变量存储为 8位（1 个字节）的数值形式，**只能是 True 或是 False**。boolean 变量的值显示为 True 或 False（在使用 Print 的时候），或者 #TRUE# 或 #FALSE#（在使用 Write # 的时候）。使用关键字True 与 False 可将 boolean 变量赋值为这两个状态中的一个。
设置代码，按下“OK”键且满足某一条件，点亮LED；按下“OK”键且满足另一条件，熄灭LED。这个条件我们用 boolean 来实现是最简单方便的，因为 boolean 只有 True 或是 False 两种状态。我们只需要设置按下“OK”键的同时 flag 为 true，即可点亮LED；同理按下“OK”键的同时 flag 为 false，熄灭LED。
---
1.2 实验组件
|  |  |  |
| -------------------------------- | ---------------------------- | ------------------------ |
| ESP32 Plus主板 x1 | Keyes 红外接收模块 x1 | Keyes 紫色LED模块 x1 |
|  |  |  |
| Keyes 遥控器 x1 | XH2.54-3P 转杜邦线母单线 x2 | USB线 x1 |
---
1.3 模块接线图
---
1.4 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_34_IR_control_LED.py**"。
```python
import time
from machine import Pin
led = Pin(5, Pin.OUT)
ird = Pin(35,Pin.IN)
act = {"1": "LLLLLLLLHHHHHHHHLHHLHLLLHLLHLHHH","2": "LLLLLLLLHHHHHHHHHLLHHLLLLHHLLHHH","3": "LLLLLLLLHHHHHHHHHLHHLLLLLHLLHHHH",
"4": "LLLLLLLLHHHHHHHHLLHHLLLLHHLLHHHH","5": "LLLLLLLLHHHHHHHHLLLHHLLLHHHLLHHH","6": "LLLLLLLLHHHHHHHHLHHHHLHLHLLLLHLH",
"7": "LLLLLLLLHHHHHHHHLLLHLLLLHHHLHHHH","8": "LLLLLLLLHHHHHHHHLLHHHLLLHHLLLHHH","9": "LLLLLLLLHHHHHHHHLHLHHLHLHLHLLHLH",
"0": "LLLLLLLLHHHHHHHHLHLLHLHLHLHHLHLH","Up": "LLLLLLLLHHHHHHHHLHHLLLHLHLLHHHLH","Down": "LLLLLLLLHHHHHHHHHLHLHLLLLHLHLHHH",
"Left": "LLLLLLLLHHHHHHHHLLHLLLHLHHLHHHLH","Right": "LLLLLLLLHHHHHHHHHHLLLLHLLLHHHHLH","Ok": "LLLLLLLLHHHHHHHHLLLLLLHLHHHHHHLH",
"*": "LLLLLLLLHHHHHHHHLHLLLLHLHLHHHHLH","#": "LLLLLLLLHHHHHHHHLHLHLLHLHLHLHHLH"}
def read_ircode(ird):
wait = 1
complete = 0
seq0 = []
seq1 = []
while wait == 1:
if ird.value() == 0:
wait = 0
while wait == 0 and complete == 0:
start = time.ticks_us()
while ird.value() == 0:
ms1 = time.ticks_us()
diff = time.ticks_diff(ms1,start)
seq0.append(diff)
while ird.value() == 1 and complete == 0:
ms2 = time.ticks_us()
diff = time.ticks_diff(ms2,ms1)
if diff > 10000:
complete = 1
seq1.append(diff)
code = ""
for val in seq1:
if val < 2000:
if val < 700:
code += "L"
else:
code += "H"
# print(code)
command = ""
for k,v in act.items():
if code == v:
command = k
if command == "":
command = code
return command
flag = False
while True:
### global flag
command = read_ircode(ird)
print(command, end = " ")
print(flag, end = " ")
if command == "Ok":
if flag == True:
led.value(1)
flag = False
print("led on")
else:
led.value(0)
flag = True
print("led off")
time.sleep(0.1)
```
---
1.5 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行。第一次按下红外遥控器上的 “**OK**” 键，此时的布尔变量“**flag**”为真，紫色LED被点亮，实现开灯的效果。“Shell”窗口打印出“**OK True led on**” 。点亮后布尔变量“**flag**”又被设置为假。
再次按下红外遥控器上的 “**OK**” 键，布尔变量“**flag**”在LED点亮后被设置为假，紫色LED熄灭，实现关灯的效果。“Shell”窗口打印出“**OK False led off**” 。
---
### 第三十五课 WiFi Station Mode
1.1 项目介绍
ESP32有3种不同的WiFi工作模式：
- Station模式（作为WiFi设备主动连接路由器，也叫做WiFi Client）
- AP模式（作为一个Access Point，让其他WiFi设备来连接）即WiFi热点
- Station+AP共存模式（ESP32连接路由器的同时自身也是一个热点供其他WiFi设备来连接）
所有WiFi编程项目在使用WiFi前必须配置WiFi运行模式，否则无法使用WiFi。在这节实验课程中，我们将学习使用ESP32的WiFi Station模式。
**Station 模式：**
当ESP32选择Station模式时，它作为一个WiFi客户端。它可以连接路由器网络，通过WiFi连接与路由器上的其他设备通信。如下图所示，PC和路由器已经连接，ESP32如果要与PC通信，需要将PC和路由器连接起来。
---
1.2 实验组件
|  |  |
| ------------------------ | --------------------- |
| ESP32 Plus主板 x1 | USB线 x1 |
---
1.3 模块接线图
---
1.4 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_35_WiFi_Station_Mode.py**"。
路由器的SSID是无线网的无线名称。SSID是 ServiceSetldentifier 的缩写，意思是:服务集标识。SSID技术可以将一个无线局域网分为几个需要不同身份验证的子网络，每一个子网络都需要独立的身份验证，只有通过身份验证的用户才可以进入相应的子网络，防止未被授权的用户进入本网络。所以在代码运行之前，需要配置 WiFi 名称和密码，将其修改为你自己使用的WiFi 名称和密码，如下图所示。
```python
import time
import network # 导入网络模块
ssidRouter = 'ChinaNet_2.4G' # 输入路由器名称
passwordRouter = 'ChinaNet@233' # 输入路由器密码
def STA_Setup(ssidRouter,passwordRouter):
print("Setup start")
sta_if = network.WLAN(network.STA_IF) # Set ESP32 in Station mode.
if not sta_if.isconnected():
print('connecting to',ssidRouter)
# 激活ESP32的Station模式，向路由器发起连接请求
# 然后输入密码进行连接。
sta_if.active(True)
sta_if.connect(ssidRouter,passwordRouter)
#等待ESP32连接到路由器，直到两者连接成功
while not sta_if.isconnected():
pass
# 在“Shell”中打印分配给ESP32-WROVER的IP地址
print('Connected, IP address:', sta_if.ifconfig())
print("Setup End")
try:
STA_Setup(ssidRouter,passwordRouter)
except:
sta_if.disconnect()
```
---
1.5 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，开始连接，当ESP32成功连接到路由器的 SSID 时，“Shell”窗口将打印出路由器分配给ESP32的**IP地址**。
**注意：如果打开串口监视器且设置好波特率，串口监视器窗口还是没有显示任何信息，可以尝试按下ESP32的RESET按键。**
---
### 第三十六课 WiFi AP Mode
1.1 项目介绍
从上一课实验中我们知道ESP32有3种不同的WiFi工作模式：
- Station模式（作为WiFi设备主动连接路由器，也叫做WiFi Client）
- AP模式（作为一个Access Point，让其他WiFi设备来连接）即WiFi热点
- Station+AP共存模式（ESP32连接路由器的同时自身也是一个热点供其他WiFi设备来连接）
所有WiFi编程项目在使用WiFi前必须配置WiFi运行模式，否则无法使用WiFi。在这节实验课程中，我们将接着学习使用ESP32的WiFi AP模式。
**AP模式：**
接入点Access Point（AP）是一种提供 Wi-Fi 网络访问的设备，并将其连接到有线网络的装置。ESP32除了不具有与有线网络的接口外，还可以提供类似的功能。这种操作模式称为软接入点（soft-AP）。可以同时连接到soft-AP的最大站数可以设置4，默认为4。
当ESP32单独处于AP模式下时，可以被认为是一个无法访问外网的局域网WiFi路由器节点，它可以接受各类设备的连接请求。并可以和连接设备进行TCP、UDP连接，实现数据流。在局域物联网的设计中可以承担数据收发节点的作用。如下图所示，以ESP32为热点。如果手机或PC需要与ESP32通信，则必须连接到ESP32的热点。只有通过与ESP32建立连接后才能进行通信。
---
1.2 实验组件
|  |  |
| ------------------------ | --------------------- |
| ESP32 Plus主板 x1 | USB线 x1 |
---
1.3 模块接线图
---
1.4 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_36_WiFi_AP_Mode.py**"。
在代码运行之前，需要配置ESP32的 AP名称和连接密码，如下图所示。当然，你也可以不修改它，使用默认的名称和连接密码。
```python
import network #导入网络模块
#请输入正确的路由器名称和密码
ssidAP = 'ESP32_WiFi' #输入路由器名称
passwordAP = '12345678' #输入路由器密码
local_IP = '192.168.1.108'
gateway = '192.168.1.1'
subnet = '255.255.255.0'
dns = '8.8.8.8'
#设置ESP32为AP模式
ap_if = network.WLAN(network.AP_IF)
def AP_Setup(ssidAP,passwordAP):
ap_if.ifconfig([local_IP,gateway,subnet,dns])
print("Setting soft-AP ... ")
ap_if.config(essid=ssidAP,authmode=network.AUTH_WPA_WPA2_PSK, password=passwordAP)
ap_if.active(True)
print('Success, IP address:', ap_if.ifconfig())
print("Setup End\n")
try:
AP_Setup(ssidAP,passwordAP)
except:
print("Failed, please disconnect the power and restart the operation.")
ap_if.disconnect()
```
---
1.5 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，打开ESP32的AP功能，“Shell”窗口中打印接入点信息。
**注意：如果打开串口监视器且设置好波特率，串口监视器窗口还是没有显示任何信息，可以尝试按下ESP32的RESET按键。**
打开手机的 WiFi 扫描功能，可以看到ESP32的 SSID ，在本课程代码中的名称为 “**ESP32_WiFi**” 。
你可以输入密码 “**12345678**” 连接它，也可以通过修改程序代码来修改它的AP名称和密码。
---
### 第三十七课 WiFi Station+AP Mode
1.1 项目介绍
从第六十课实验中我们知道ESP32有3种不同的WiFi工作模式：
- Station模式（作为WiFi设备主动连接路由器，也叫做WiFi Client）
- AP模式（作为一个Access Point，让其他WiFi设备来连接）即WiFi热点
- Station+AP共存模式（ESP32连接路由器的同时自身也是一个热点供其他WiFi设备来连接）
所有WiFi编程项目在使用WiFi前必须配置WiFi运行模式，否则无法使用WiFi。在这节实验课程中，我们将接着学习使用ESP32的WiFi Station+AP模式。
**AP+Station模式：**
ESP32除AP模式和Station模式外，还可以同时使用AP模式和Station模式。此模式包含前两种模式的功能。打开ESP32的Station模式，将其连接到路由器网络，它可以通过路由器与Internet通信。同时开启其AP模式，创建热点网络。其他WiFi设备可以选择连接路由器网络或热点网络与ESP32通信。
---
1.2 实验组件
|  |  |
| ------------------------ | --------------------- |
| ESP32 Plus主板 x1 | USB线 x1 |
---
1.3 模块接线图
---
1.4 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_37_WiFi_Station+AP_Mode.py**"。
在代码运行之前，需要配置 WiFi 名称和密码、ESP32的 AP名称和连接密码，如下图所示。
```python
import network #导入网络模块
ssidRouter = 'ChinaNet_2.4G' #输入路由器名称
passwordRouter = 'ChinaNet@233' #输入路由器密码
ssidAP = 'ESP32_WiFi'#输入AP名称
passwordAP = '12345678' #输入AP密码
local_IP = '192.168.4.147'
gateway = '192.168.1.1'
subnet = '255.255.255.0'
dns = '8.8.8.8'
sta_if = network.WLAN(network.STA_IF)
ap_if = network.WLAN(network.AP_IF)
def STA_Setup(ssidRouter,passwordRouter):
print("Setting soft-STA ... ")
if not sta_if.isconnected():
print('connecting to',ssidRouter)
sta_if.active(True)
sta_if.connect(ssidRouter,passwordRouter)
while not sta_if.isconnected():
pass
print('Connected, IP address:', sta_if.ifconfig())
print("Setup End")
def AP_Setup(ssidAP,passwordAP):
ap_if.ifconfig([local_IP,gateway,subnet,dns])
print("Setting soft-AP ... ")
ap_if.config(essid=ssidAP,authmode=network.AUTH_WPA_WPA2_PSK, password=passwordAP)
ap_if.active(True)
print('Success, IP address:', ap_if.ifconfig())
print("Setup End\n")
try:
AP_Setup(ssidAP,passwordAP)
STA_Setup(ssidRouter,passwordRouter)
except:
sta_if.disconnect()
ap_if.idsconnect()
```
---
1.5 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码。代码开始执行，开始连接，“Shell”窗口中将显示如下：
**注意：如果打开串口监视器且设置好波特率，串口监视器窗口还是没有显示任何信息，可以尝试按下ESP32的RESET按键。**
打开手机 WiFi 扫描功能，可以看到ESP32的SSID，名称为 “**ESP32_WiFi**” 。
---
### 第三十八课 综合实验
1.1 项目介绍
我们已经学习了所有的模块和传感器的使用方法，也学习了将它们搭配在一起组合实验。在这一实验课程中我们将搭配更多的模块和传感器组合在一起。参考前面实验编程的方法，利用按键模块，实现每按一次按键，功能就变换一次的效果。
实验多种多样，大家可以发挥想象力，搭配模块和传感器做出更多具有意义的实验。
---
1.2 实验组件
|  |  |  |  |
| ---------------------------- | ------------------------ | ---------------------------- | ---------------------------- |
| ESP32 Plus主板 x1 | Keyes 紫色LED模块 x1 | Keyes 单路按键模块 x1 | Keyes 旋转电位器模块 x1 |
|  |  |  |  |
| Keyes 避障传感器 x1 | Keyes 摇杆模块 x1 | HC-SR04 超声波传感器 x1 | Keyes 超声波转接模块 x1 |
|  |  |  |  |
| Keyes 共阴RGB模块 x1 | USB线 x1 | XH2.54-3P 转杜邦线母单线 x4 | XH2.54-4P 转杜邦线母单线 x2 |
|  | | | |
| XH2.54-5P 转杜邦线母单线 x1 | | | |
---
1.3 模块接线图
---
1.4 在线运行代码
打开Thonny并单击，然后单击“**此电脑**”。
选中“**D:\代码**”路径，打开代码文件''**lesson_38_Comprehensive_experiment.py**"。
```python
from machine import ADC, Pin, PWM
import time
import machine
import random
pwm_r = PWM(Pin(2))
pwm_g = PWM(Pin(4))
pwm_b = PWM(Pin(32))
pwm_r.freq(1000)
pwm_g.freq(1000)
pwm_b.freq(1000)
potentiometer_adc=ADC(Pin(35))
potentiometer_adc.atten(ADC.ATTN_11DB)
potentiometer_adc.width(ADC.WIDTH_10BIT)
button = Pin(23, Pin.IN)
led = PWM(Pin(5,Pin.OUT),1000)
Avoiding = Pin(14, Pin.IN, Pin.PULL_UP)
button_z=Pin(18,Pin.IN,Pin.PULL_UP)
rocker_x=ADC(Pin(33))
rocker_y=ADC(Pin(34))
rocker_x.atten(ADC.ATTN_11DB)
rocker_y.atten(ADC.ATTN_11DB)
rocker_x.width(ADC.WIDTH_10BIT)
rocker_y.width(ADC.WIDTH_10BIT)
### 设置超声波引脚
trigger = Pin(13, Pin.OUT)
echo = Pin(12, Pin.IN)
def light(red, green, blue):
pwm_r.duty(red)
pwm_g.duty(green)
pwm_b.duty(blue)
### 超声波测距，单位:厘米
def getDistance(trigger, echo):
# 产生10us方波
trigger.value(0) #事先给一个短的低电平，以确保一个干净的高脉冲;
time.sleep_us(2)
trigger.value(1)
time.sleep_us(10)#拉高后，等待10微秒，立即调低
trigger.value(0)
while echo.value() == 0: #建立while循环，检测回波引脚值是否为0，并记录此时的时间
start = time.ticks_us()
while echo.value() == 1: #建立while循环，检查回波引脚值是否为1，并记录此时的时间
end = time.ticks_us()
d = (end - start) * 0.0343 / 2 #声波的传播时间x声速(343.2 m/s, 0.0343 cm/微秒)，再除以来回距离2
return d
keys = 0
nums = 0
print(keys % 5)
def toggle_handle(pin):
global keys
keys += 1
print(keys % 4)
button.irq(trigger = Pin.IRQ_FALLING, handler = toggle_handle)
def showRGB():
R = random.randint(0,1023)
G = random.randint(0,1023)
B = random.randint(0,1023)
light(R, G, B)
time.sleep(0.3)
def showAvoiding():
if Avoiding.value() == 0:
print("0 There are obstacles") #按下打印相应信息
else:
print("1 All going well")
time.sleep(0.1) #延时0.1秒
def showJoystick():
B_value = button_z.value()
X_value = rocker_x.read()
Y_value = rocker_y.read()
print("button:", end = " ")
print(B_value, end = " ")
print("X:", end = " ")
print(X_value, end = " ")
print("Y:", end = " ")
print(Y_value)
time.sleep(0.1)
def adjustLight():
pot_value = potentiometer_adc.read()
led.duty(pot_value)
print(pot_value)
time.sleep(0.1)
def showDistance():
distance = getDistance(trigger, echo)
print("The distance is ：{:.2f} cm".format(distance))
time.sleep(0.1)
while True:
nums = keys % 5 #按键次数对5取模得到0,1,2,3,4
if nums == 0: #根据RGB
showRGB()
elif nums == 1: #显示避让传感器的高低电平
showAvoiding()
elif nums == 2: #显示摇杆值
showJoystick()
elif nums == 3: #电位器调节LED
adjustLight()
elif nums == 4: #显示超声波测距值
showDistance()
```
---
1.5 实验结果
按照接线图正确接好模块，用USB线连接到计算机上电，单击来执行程序代码，代码开始执行。
（1）初始时没有按下按键，按键次数为 0 ，余数为 0 ，RGB模块循环闪烁随机颜色。
（2）按一下按键（时间稍长以便能检测到按键按下），RGB LED灯停止闪烁。此时按键次数为 1 ，余数为 1 ，实验实现避障传感器检测障碍物并读取高低电平的功能。
当传感器没有检测到障碍物时，value为**1**，“Shell”窗口打印出 “**1 All going well**” ，灯 SLED **不亮**；
当传感器检测到障碍物时，value为**0**，“Shell”窗口打印出 “**0 There are obstacles**” ，灯 SLED **亮**。
（3）再按一下按键，按键次数为 2 ，余数为 2 。实验实现读取当前摇杆X轴和Y轴对应的模拟值以及Z轴（B接口）对应的数字值的功能。“Shell”窗口打印出当前摇杆X轴、Y轴和Z轴对应的值。
（4）再按一下按键，按键次数为 3 ，余数为 3 。实验实现利用可调电位器模块调节 LED（GPIO5）接口输出的PWM值，从而调节紫色LED模块上LED亮度的功能。“Shell”窗口打印出当前输出的模拟值。
（5）再按一下按键，按键次数为 4 ，余数为 4 。实验实现的功能是利用超声波模块检测距离并在“Shell”窗口打印出来，“Shell”窗口显示图如下。
（6）再按一下按键，按键次数为 5 ，余数为 0 。实现初始时RGB循环闪烁随机颜色的效果。不断地按下按键，余数循环变化，实验功能也循环变化。